Formatting + init server

jael_language_server/.gitignore

@@ -0,0 +1,21 @@
+# See https://www.dartlang.org/guides/libraries/private-files
+
+# Files and directories created by pub
+.dart_tool/
+.packages
+build/
+# If you're building an application, you may want to check-in your pubspec.lock
+pubspec.lock
+
+# Directory created by dartdoc
+# If you don't generate documentation locally you can remove this line.
+doc/api/
+
+# Avoid committing generated Javascript files:
+*.dart.js
+*.info.json      # Produced by the --dump-info flag.
+*.js             # When generated by dart2js. Don't specify *.js if your
+                 # project includes source files written in JavaScript.
+*.js_
+*.js.deps
+*.js.map

jael_language_server/analysis_options.yaml

@@ -0,0 +1,3 @@
+analyzer:
+  strong-mode:
+    implicit-casts: false

jael_language_server/bin/jael_language_server.dart

@@ -0,0 +1,68 @@
+import 'dart:async';
+import 'dart:io';
+import 'package:args/args.dart';
+import 'package:io/ansi.dart';
+import 'package:io/io.dart';
+import 'package:dart_language_server/dart_language_server.dart';
+import 'package:jael_language_server/jael_language_server.dart';
+
+main(List<String> args) async {
+  var argParser = new ArgParser()
+    ..addFlag('help',
+        abbr: 'h', negatable: false, help: 'Print this help information.')
+    ..addOption('log-file', help: 'A path to which to write a log file.');
+
+  void printUsage() {
+    print('usage: jael_language_server [options...]\n\nOptions:');
+    print(argParser.usage);
+  }
+
+  try {
+    var argResults = argParser.parse(args);
+
+    if (argResults['help'] as bool) {
+      printUsage();
+      return;
+    } else {
+      var jaelServer = new JaelLanguageServer();
+
+      if (argResults.wasParsed('log-file')) {
+        var f = new File(argResults['log-file'] as String);
+        await f.create(recursive: true);
+
+        jaelServer.logger.onRecord.listen((rec) async {
+          var sink = await f.openWrite(mode: FileMode.append);
+          sink.writeln(rec);
+          if (rec.error != null) sink.writeln(rec.error);
+          if (rec.stackTrace != null) sink.writeln(rec.stackTrace);
+          await sink.close();
+        });
+      } else {
+        jaelServer.logger.onRecord.listen((rec) async {
+          var sink = stderr;
+          sink.writeln(rec);
+          if (rec.error != null) sink.writeln(rec.error);
+          if (rec.stackTrace != null) sink.writeln(rec.stackTrace);
+        });
+      }
+
+      var spec = new ZoneSpecification(
+        handleUncaughtError: (self, parent, zone, error, stackTrace) {
+          jaelServer.logger.severe('Uncaught', error, stackTrace);
+        },
+        print: (self, parent, zone, line) {
+          jaelServer.logger.info(line);
+        },
+      );
+      var zone = Zone.current.fork(specification: spec);
+      await zone.run(() async {
+        var stdio = new StdIOLanguageServer.start(jaelServer);
+        await stdio.onDone;
+      });
+    }
+  } on ArgParserException catch (e) {
+    print('${red.wrap('error')}: ${e.message}\n');
+    printUsage();
+    exitCode = ExitCode.usage.code;
+  }
+}

jael_language_server/lib/jael_language_server.dart

@@ -0,0 +1 @@
+export 'src/server.dart';

jael_language_server/lib/src/analyzer.dart

@@ -0,0 +1,153 @@
+import 'package:jael/jael.dart';
+import 'package:logging/logging.dart';
+import 'package:symbol_table/symbol_table.dart';
+import 'object.dart';
+
+class Analyzer extends Parser {
+  final Logger logger;
+  Analyzer(Scanner scanner, this.logger) : super(scanner);
+
+  final errors = <JaelError>[];
+  var _scope = new SymbolTable<JaelObject>();
+  var allDefinitions = <Variable<JaelObject>>[];
+
+  SymbolTable<JaelObject> get parentScope =>
+      _scope.isRoot ? _scope : _scope.parent;
+
+  SymbolTable<JaelObject> get scope => _scope;
+
+  bool ensureAttributeIsPresent(Element element, String name) {
+    if (element.getAttribute(name)?.value == null) {
+      addError(new JaelError(JaelErrorSeverity.error,
+          'Missing required attribute `$name`.', element.span));
+      return false;
+    }
+    return true;
+  }
+
+  void addError(JaelError e) {
+    errors.add(e);
+    logger.severe(e.message, e.span.highlight());
+  }
+
+  bool ensureAttributeIsConstantString(Element element, String name) {
+    var a = element.getAttribute(name);
+    if (a?.value is! StringLiteral || a?.value == null) {
+      var e = new JaelError(
+          JaelErrorSeverity.warning,
+          "`$name` attribute should be a constant string literal.",
+          a?.span ?? element.tagName.span);
+      addError(e);
+      return false;
+    }
+
+    return true;
+  }
+
+  @override
+  Element parseElement() {
+    try {
+      _scope = _scope.createChild();
+      var element = super.parseElement();
+      if (element == null) return null;
+
+      // Check if any custom element exists.
+      _scope
+          .resolve(element.tagName.name)
+          ?.value
+          ?.usages
+          ?.add(new SymbolUsage(SymbolUsageType.read, element.span));
+
+      // Validate attrs
+      var forEach = element.getAttribute('for-each');
+      if (forEach != null) {
+        var asAttr = element.getAttribute('as');
+        if (asAttr != null) {
+          if (ensureAttributeIsConstantString(element, 'as')) {
+            var asName = asAttr.string.value;
+            _scope.create(asName,
+                value: new JaelVariable(asName, asAttr.span), constant: true);
+          }
+        }
+
+        if (forEach.value != null) {
+          addError(new JaelError(JaelErrorSeverity.error,
+              'Missing value for `for-each` directive.', forEach.span));
+        }
+      }
+
+      var iff = element.getAttribute('if');
+      if (iff != null) {
+        if (iff.value != null) {
+          addError(new JaelError(JaelErrorSeverity.error,
+              'Missing value for `iff` directive.', iff.span));
+        }
+      }
+
+      // Validate the tag itself
+      if (element is RegularElement) {
+        if (element.tagName.name == 'block') {
+          ensureAttributeIsConstantString(element, 'name');
+          //logger.info('Found <block> at ${element.span.start.toolString}');
+        } else if (element.tagName.name == 'case') {
+          ensureAttributeIsPresent(element, 'value');
+          //logger.info('Found <case> at ${element.span.start.toolString}');
+        } else if (element.tagName.name == 'declare') {
+          if (element.attributes.isEmpty) {
+            addError(new JaelError(
+                JaelErrorSeverity.warning,
+                '`declare` directive does not define any new symbols.',
+                element.tagName.span));
+          } else {
+            for (var attr in element.attributes) {
+              _scope.create(attr.name,
+                  value: new JaelVariable(attr.name, attr.span));
+            }
+          }
+        } else if (element.tagName.name == 'element') {
+          if (ensureAttributeIsConstantString(element, 'name')) {
+            var nameCtx = element.getAttribute('name').value as StringLiteral;
+            var name = nameCtx.value;
+            //logger.info(
+            //    'Found custom element $name at ${element.span.start.toolString}');
+            try {
+              var symbol = parentScope.create(name,
+                  value: new JaelCustomElement(name, element.tagName.span),
+                  constant: true);
+              allDefinitions.add(symbol);
+            } on StateError catch (e) {
+              addError(new JaelError(
+                  JaelErrorSeverity.error, e.message, element.tagName.span));
+            }
+          }
+        } else if (element.tagName.name == 'extend') {
+          ensureAttributeIsConstantString(element, 'src');
+          //logger.info('Found <extend> at ${element.span.start.toolString}');
+        }
+      } else if (element is SelfClosingElement) {
+        if (element.tagName.name == 'include') {
+          //logger.info('Found <include> at ${element.span.start.toolString}');
+          ensureAttributeIsConstantString(element, 'src');
+        }
+      }
+
+      return element;
+    } finally {
+      _scope = _scope.parent;
+      return null;
+    }
+  }
+
+  @override
+  Expression parseExpression(int precedence) {
+    var expr = super.parseExpression(precedence);
+    if (expr == null) return null;
+
+    if (expr is Identifier) {
+      var ref = _scope.resolve(expr.name);
+      ref?.value?.usages?.add(new SymbolUsage(SymbolUsageType.read, expr.span));
+    }
+
+    return expr;
+  }
+}

jael_language_server/lib/src/object.dart

@@ -0,0 +1,32 @@
+import 'dart:collection';
+
+import 'package:source_span/source_span.dart';
+
+abstract class JaelObject {
+  final FileSpan span;
+  final usages = <SymbolUsage>[];
+  String get name;
+
+  JaelObject(this.span);
+}
+
+class JaelCustomElement extends JaelObject {
+  final String name;
+  final attributes = new SplayTreeSet<String>();
+
+  JaelCustomElement(this.name, FileSpan span) : super(span);
+}
+
+class JaelVariable extends JaelObject {
+  final String name;
+  JaelVariable(this.name, FileSpan span) : super(span);
+}
+
+class SymbolUsage {
+  final SymbolUsageType type;
+  final FileSpan span;
+
+  SymbolUsage(this.type, this.span);
+}
+
+enum SymbolUsageType { definition, read }

jael_language_server/lib/src/server.dart

@@ -0,0 +1,554 @@
+import 'dart:async';
+import 'package:dart_language_server/src/protocol/language_server/interface.dart';
+import 'package:dart_language_server/src/protocol/language_server/messages.dart';
+import 'package:file/file.dart';
+import 'package:file/local.dart';
+import 'package:file/memory.dart';
+import 'package:jael/jael.dart';
+import 'package:json_rpc_2/json_rpc_2.dart' as json_rpc_2;
+import 'package:logging/logging.dart';
+import 'package:path/path.dart' as p;
+import 'package:source_span/source_span.dart';
+import 'package:string_scanner/string_scanner.dart';
+import 'package:symbol_table/symbol_table.dart';
+import 'analyzer.dart';
+import 'object.dart';
+
+class JaelLanguageServer extends LanguageServer {
+  var _diagnostics = new StreamController<Diagnostics>();
+  var _done = new Completer();
+  var _memFs = new MemoryFileSystem();
+  var _localFs = const LocalFileSystem();
+  Directory _localRootDir, _memRootDir;
+  var logger = new Logger('jael');
+  Uri _rootUri;
+  var _workspaceEdits = new StreamController<ApplyWorkspaceEditParams>();
+
+  @override
+  Stream<Diagnostics> get diagnostics => _diagnostics.stream;
+
+  @override
+  Future<void> get onDone => _done.future;
+
+  @override
+  Stream<ApplyWorkspaceEditParams> get workspaceEdits => _workspaceEdits.stream;
+
+  @override
+  Future<void> shutdown() {
+    if (!_done.isCompleted) _done.complete();
+    _diagnostics.close();
+    _workspaceEdits.close();
+    return super.shutdown();
+  }
+
+  @override
+  void setupExtraMethods(json_rpc_2.Peer peer) {
+    peer.registerMethod('textDocument/formatting',
+        (json_rpc_2.Parameters params) async {
+      var documentId =
+          new TextDocumentIdentifier.fromJson(params['textDocument'].asMap);
+      var formattingOptions =
+          new FormattingOptions.fromJson(params['options'].asMap);
+      return await textDocumentFormatting(documentId, formattingOptions);
+    });
+  }
+
+  @override
+  Future<ServerCapabilities> initialize(int clientPid, String rootUri,
+      ClientCapabilities clientCapabilities, String trace) async {
+    // Find our real root dir.
+    _localRootDir = _localFs.directory(_rootUri = Uri.parse(rootUri));
+    _memRootDir = _memFs.directory('/');
+    await _memRootDir.create(recursive: true);
+    _memFs.currentDirectory = _memRootDir;
+
+    // Copy all real files that end in *.jael (and *.jl for legacy) into the in-memory filesystem.
+    await for (var entity in _localRootDir.list(recursive: true)) {
+      if (entity is File && p.extension(entity.path) == '.jael') {
+        logger.info('HEY ${entity.path}');
+        var file = _memFs.file(entity.absolute.path);
+        await file.create(recursive: true);
+        await entity
+            .openRead()
+            .cast<List<int>>()
+            .pipe(file.openWrite(mode: FileMode.write));
+        logger.info(
+            'Found Jael file ${file.path}; copied to ${file.absolute.path}');
+
+        // Analyze it
+        var documentId = new TextDocumentIdentifier((b) {
+          b..uri = _rootUri.replace(path: file.path).toString();
+        });
+
+        await analyzerForId(documentId);
+      }
+    }
+
+    return new ServerCapabilities((b) {
+      b
+        ..codeActionProvider = false
+        ..completionProvider = new CompletionOptions((b) {
+          b
+            ..resolveProvider = true
+            ..triggerCharacters =
+                'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdeghijklmnopqrstuvxwyz'
+                    .codeUnits
+                    .map((c) => new String.fromCharCode(c))
+                    .toList();
+        })
+        ..definitionProvider = true
+        ..documentHighlightProvider = true
+        ..documentRangeFormattingProvider = false
+        ..documentOnTypeFormattingProvider = null
+        ..documentSymbolProvider = true
+        ..documentFormattingProvider = true
+        ..hoverProvider = true
+        ..implementationProvider = true
+        ..referencesProvider = true
+        ..renameProvider = true
+        ..signatureHelpProvider = new SignatureHelpOptions((b) {})
+        ..textDocumentSync = new TextDocumentSyncOptions((b) {
+          b
+            ..openClose = true
+            ..change = TextDocumentSyncKind.full
+            ..save = new SaveOptions((b) {
+              b..includeText = false;
+            })
+            ..willSave = false
+            ..willSaveWaitUntil = false;
+        })
+        ..workspaceSymbolProvider = true;
+    });
+  }
+
+  Future<File> fileForId(TextDocumentIdentifier documentId) async {
+    var uri = Uri.parse(documentId.uri);
+    var relativePath = uri.path;
+    var file = _memFs.directory('/').childFile(relativePath);
+
+    /*
+    logger.info('Searching for $relativePath. All:\n');
+
+    await for (var entity in _memFs.directory('/').list(recursive: true)) {
+      if (entity is File) print(' * ${entity.absolute.path}');
+    }
+    */
+
+    if (!await file.exists()) {
+      await file.create(recursive: true);
+      await _localFs
+          .file(uri)
+          .openRead()
+          .cast<List<int>>()
+          .pipe(file.openWrite());
+      logger.info('Opened Jael file ${file.path}');
+    }
+
+    return file;
+  }
+
+  Future<Scanner> scannerForId(TextDocumentIdentifier documentId) async {
+    var file = await fileForId(documentId);
+    return scan(await file.readAsString(), sourceUrl: file.uri);
+  }
+
+  Future<Analyzer> analyzerForId(TextDocumentIdentifier documentId) async {
+    var scanner = await scannerForId(documentId);
+    var analyzer = new Analyzer(scanner, logger)..errors.addAll(scanner.errors);
+    analyzer.parseDocument();
+    emitDiagnostics(documentId.uri, analyzer.errors.map(toDiagnostic).toList());
+    return analyzer;
+  }
+
+  Diagnostic toDiagnostic(JaelError e) {
+    return new Diagnostic((b) {
+      b
+        ..message = e.message
+        ..range = toRange(e.span)
+        ..severity = toSeverity(e.severity)
+        ..source = e.span.start.sourceUrl.toString();
+    });
+  }
+
+  int toSeverity(JaelErrorSeverity s) {
+    switch (s) {
+      case JaelErrorSeverity.warning:
+        return DiagnosticSeverity.warning;
+      default:
+        return DiagnosticSeverity.error;
+    }
+  }
+
+  Range toRange(FileSpan span) {
+    return new Range((b) {
+      b
+        ..start = toPosition(span.start)
+        ..end = toPosition(span.end);
+    });
+  }
+
+  Range emptyRange() {
+    return new Range((b) => b
+      ..start = b.end = new Position((b) {
+        b
+          ..character = 1
+          ..line = 0;
+      }));
+  }
+
+  Position toPosition(SourceLocation location) {
+    return new Position((b) {
+      b
+        ..line = location.line
+        ..character = location.column;
+    });
+  }
+
+  Location toLocation(String uri, FileSpan span) {
+    return new Location((b) {
+      b
+        ..range = toRange(span)
+        ..uri = uri;
+    });
+  }
+
+  bool isReachable(JaelObject obj, Position position) {
+    return obj.span.start.line <= position.line &&
+        obj.span.start.column <= position.character;
+  }
+
+  CompletionItem toCompletion(Variable<JaelObject> symbol) {
+    var value = symbol.value;
+
+    if (value is JaelCustomElement) {
+      var name = value.name;
+      return new CompletionItem((b) {
+        b
+          ..kind = CompletionItemKind.classKind
+          ..label = symbol.name
+          ..textEdit = new TextEdit((b) {
+            b
+              ..range = emptyRange()
+              ..newText = '<$name\$1>\n    \$2\n</name>';
+          });
+      });
+    } else if (value is JaelVariable) {
+      return new CompletionItem((b) {
+        b
+          ..kind = CompletionItemKind.variable
+          ..label = symbol.name;
+      });
+    }
+
+    return null;
+  }
+
+  void emitDiagnostics(String uri, Iterable<Diagnostic> diagnostics) {
+    _diagnostics.add(new Diagnostics((b) {
+      logger.info('$uri => ${diagnostics.map((d) => d.message).toList()}');
+      b
+        ..diagnostics = diagnostics.toList()
+        ..uri = uri.toString();
+    }));
+  }
+
+  @override
+  Future textDocumentDidOpen(TextDocumentItem document) async {
+    await analyzerForId(
+        new TextDocumentIdentifier((b) => b..uri = document.uri));
+  }
+
+  @override
+  Future textDocumentDidChange(VersionedTextDocumentIdentifier documentId,
+      List<TextDocumentContentChangeEvent> changes) async {
+    var id = new TextDocumentIdentifier((b) => b..uri = documentId.uri);
+    var file = await fileForId(id);
+
+    for (var change in changes) {
+      if (change.text != null) {
+        await file.writeAsString(change.text);
+      } else if (change.range != null) {
+        var contents = await file.readAsString();
+
+        int findIndex(Position position) {
+          var lines = contents.split('\n');
+
+          // Sum the length of the previous lines.
+          int lineLength = lines
+              .take(position.line - 1)
+              .map((s) => s.length)
+              .reduce((a, b) => a + b);
+          return lineLength + position.character - 1;
+        }
+
+        if (change.range == null) {
+          contents = change.text;
+        } else {
+          var start = findIndex(change.range.start),
+              end = findIndex(change.range.end);
+          contents = contents.replaceRange(start, end, change.text);
+        }
+
+        logger.info('${file.path} => $contents');
+        await file.writeAsString(contents);
+      }
+    }
+
+    await analyzerForId(id);
+  }
+
+  @override
+  Future<List> textDocumentCodeAction(TextDocumentIdentifier documentId,
+      Range range, CodeActionContext context) async {
+    // TODO: implement textDocumentCodeAction
+    return [];
+  }
+
+  @override
+  Future<CompletionList> textDocumentCompletion(
+      TextDocumentIdentifier documentId, Position position) async {
+    var analyzer = await analyzerForId(documentId);
+    var symbols = analyzer.scope.allVariables;
+    var reachable = symbols.where((s) => isReachable(s.value, position));
+    return new CompletionList((b) {
+      b
+        ..isIncomplete = false
+        ..items = reachable.map(toCompletion).toList();
+    });
+  }
+
+  final RegExp _id =
+      new RegExp(r'(([A-Za-z][A-Za-z0-9_]*-)*([A-Za-z][A-Za-z0-9_]*))');
+
+  Future<String> currentName(
+      TextDocumentIdentifier documentId, Position position) async {
+    // First, read the file.
+    var file = await fileForId(documentId);
+    var contents = await file.readAsString();
+
+    // Next, find the current index.
+    var scanner = new SpanScanner(contents);
+
+    while (!scanner.isDone &&
+        (scanner.state.line != position.line ||
+            scanner.state.column != position.character)) {
+      scanner.readChar();
+    }
+
+    // Next, just read the name.
+    if (scanner.matches(_id)) {
+      var longest = scanner.lastSpan.text;
+
+      while (scanner.matches(_id) && scanner.position > 0 && !scanner.isDone) {
+        longest = scanner.lastSpan.text;
+        scanner.position--;
+      }
+
+      return longest;
+    } else {
+      return null;
+    }
+  }
+
+  Future<JaelObject> currentSymbol(
+      TextDocumentIdentifier documentId, Position position) async {
+    var name = await currentName(documentId, position);
+    if (name == null) return null;
+    var analyzer = await analyzerForId(documentId);
+    var symbols = analyzer.allDefinitions ?? analyzer.scope.allVariables;
+    logger
+        .info('Current symbols, seeking $name: ${symbols.map((v) => v.name)}');
+    return analyzer.scope.resolve(name)?.value;
+  }
+
+  @override
+  Future<Location> textDocumentDefinition(
+      TextDocumentIdentifier documentId, Position position) async {
+    var symbol = await currentSymbol(documentId, position);
+    if (symbol != null) {
+      return toLocation(documentId.uri, symbol.span);
+    }
+    return null;
+  }
+
+  @override
+  Future<List<DocumentHighlight>> textDocumentHighlight(
+      TextDocumentIdentifier documentId, Position position) async {
+    var symbol = await currentSymbol(documentId, position);
+    if (symbol != null) {
+      return symbol.usages.map((u) {
+        return new DocumentHighlight((b) {
+          b
+            ..range = toRange(u.span)
+            ..kind = u.type == SymbolUsageType.definition
+                ? DocumentHighlightKind.write
+                : DocumentHighlightKind.read;
+        });
+      }).toList();
+    }
+    return [];
+  }
+
+  @override
+  Future<Hover> textDocumentHover(
+      TextDocumentIdentifier documentId, Position position) async {
+    var symbol = await currentSymbol(documentId, position);
+    if (symbol != null) {
+      return new Hover((b) {
+        b
+          ..contents = symbol.span.text
+          ..range = toRange(symbol.span);
+      });
+    }
+
+    return null;
+  }
+
+  @override
+  Future<List<Location>> textDocumentImplementation(
+      TextDocumentIdentifier documentId, Position position) async {
+    var defn = await textDocumentDefinition(documentId, position);
+    return defn == null ? [] : [defn];
+  }
+
+  @override
+  Future<List<Location>> textDocumentReferences(
+      TextDocumentIdentifier documentId,
+      Position position,
+      ReferenceContext context) async {
+    var symbol = await currentSymbol(documentId, position);
+    if (symbol != null) {
+      return symbol.usages.map((u) {
+        return toLocation(documentId.uri, u.span);
+      }).toList();
+    }
+
+    return [];
+  }
+
+  @override
+  Future<WorkspaceEdit> textDocumentRename(TextDocumentIdentifier documentId,
+      Position position, String newName) async {
+    var symbol = await currentSymbol(documentId, position);
+    if (symbol != null) {
+      return new WorkspaceEdit((b) {
+        b
+          ..changes = {
+            symbol.name: symbol.usages.map((u) {
+              return new TextEdit((b) {
+                b
+                  ..range = toRange(u.span)
+                  ..newText = (symbol is JaelCustomElement &&
+                          u.type == SymbolUsageType.definition)
+                      ? '"$newName"'
+                      : newName;
+              });
+            }).toList()
+          };
+      });
+    }
+    return new WorkspaceEdit((b) {
+      b..changes = {};
+    });
+  }
+
+  @override
+  Future<List<SymbolInformation>> textDocumentSymbols(
+      TextDocumentIdentifier documentId) async {
+    var analyzer = await analyzerForId(documentId);
+    return analyzer.allDefinitions.map((symbol) {
+      return new SymbolInformation((b) {
+        b
+          ..kind = SymbolKind.classSymbol
+          ..name = symbol.name
+          ..location = toLocation(documentId.uri, symbol.value.span);
+      });
+    }).toList();
+  }
+
+  @override
+  Future<void> workspaceExecuteCommand(String command, List arguments) async {
+    // TODO: implement workspaceExecuteCommand
+  }
+
+  @override
+  Future<List<SymbolInformation>> workspaceSymbol(String query) async {
+    var values = <JaelObject>[];
+
+    await for (var file in _memRootDir.list(recursive: true)) {
+      if (file is File) {
+        var id = new TextDocumentIdentifier((b) {
+          b..uri = file.uri.toString();
+        });
+        var analyzer = await analyzerForId(id);
+        values.addAll(analyzer.allDefinitions.map((v) => v.value));
+      }
+    }
+
+    return values.map((o) {
+      return new SymbolInformation((b) {
+        b
+          ..name = o.name
+          ..location = toLocation(o.span.sourceUrl.toString(), o.span)
+          ..containerName = p.basename(o.span.sourceUrl.path)
+          ..kind = o is JaelCustomElement
+              ? SymbolKind.classSymbol
+              : SymbolKind.variable;
+      });
+    }).toList();
+  }
+
+  Future<List<TextEdit>> textDocumentFormatting(
+      TextDocumentIdentifier documentId,
+      FormattingOptions formattingOptions) async {
+    try {
+      var errors = <JaelError>[];
+      var file = await fileForId(documentId);
+      var contents = await file.readAsString();
+      var document =
+          parseDocument(contents, sourceUrl: file.uri, onError: errors.add);
+      if (errors.isNotEmpty) return null;
+      var formatter = new JaelFormatter(
+          formattingOptions.tabSize, formattingOptions.insertSpaces, 80);
+      var formatted = formatter.apply(document);
+      logger.info('Original:${contents}\nFormatted:\n$formatted');
+      if (formatted.isNotEmpty) await file.writeAsString(formatted);
+      return [
+        new TextEdit((b) {
+          b
+            ..newText = formatted
+            ..range = document == null ? emptyRange() : toRange(document.span);
+        })
+      ];
+    } catch (e, st) {
+      logger.severe('Formatter error', e, st);
+      return null;
+    }
+  }
+
+  @override
+  void initialized() {
+    // TODO: implement initialized
+  }
+
+  @override
+  // TODO: implement showMessages
+  Stream<ShowMessageParams> get showMessages => null;
+}
+
+abstract class DiagnosticSeverity {
+  static const int error = 0, warning = 1, information = 2, hint = 3;
+}
+
+class FormattingOptions {
+  final num tabSize;
+
+  final bool insertSpaces;
+
+  FormattingOptions(this.tabSize, this.insertSpaces);
+
+  factory FormattingOptions.fromJson(Map json) {
+    return new FormattingOptions(
+        json['tabSize'] as num, json['insertSpaces'] as bool);
+  }
+}

jael_language_server/pubspec.yaml

@@ -0,0 +1,22 @@
+name: jael_language_server
+version: 0.0.0
+description: Language Server Protocol implementation for the Jael templating engine.
+author: Tobe Osakwe <thosakwe@gmail.com>
+homepage: https://github.com/angel-dart/vscode
+environment:
+  sdk: ">=2.0.0-dev <3.0.0"
+dependencies:
+  args: ^1.0.0
+  dart_language_server: ^0.1.3
+  file: ^5.0.0
+  io: ^0.3.2
+  jael: ^2.0.0
+  jael_preprocessor: ^2.0.0
+  json_rpc_2: ^2.0.0
+  logging: ^0.11.3
+  path: ^1.0.0
+  source_span: ^1.0.0
+  string_scanner: ^1.0.0
+  symbol_table: ^2.0.0
+executables:
+  jael_language_server: jael_language_server