add source maps support, fixes #50

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library ddc.src.codegen.js_codegen;
 
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
+import 'package:source_maps/source_maps.dart' as srcmaps show Printer;
+import 'package:source_maps/source_maps.dart' show SourceMapSpan;
+import 'package:source_span/source_span.dart' show SourceLocation;
 import 'package:path/path.dart' as path;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart' as JS;
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
+import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/report.dart';
 import 'package:dev_compiler/src/utils.dart';
 import 'code_generator.dart';
 
 // This must match the optional parameter name used in runtime.js
 const String _jsNamedParameterName = r'opt$';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
@@ skipping 19 matching lines @@
   JS.Block generateLibrary(
       Iterable<CompilationUnit> units, CheckerReporter reporter) {
     var body = <JS.Statement>[];
     for (var unit in units) {
       // TODO(jmesserly): this is needed because RestrictedTypeRules can send
       // messages to CheckerReporter, for things like missing types.
       // We should probably refactor so this can't happen.
       var source = unit.element.source;
       _constEvaluator = new ConstantEvaluator(source, rules.provider);
       reporter.enterSource(source);
-      body.add(unit.accept(this));
+      body.add(_visit(unit));
       reporter.leaveSource();
     }
 
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       body.add(js.statement('#.# = #;', [_libraryName, name, name]));
     }
 
@@ skipping 11 matching lines @@
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
       if (child is! FunctionDeclaration) _flushLibraryProperties(body);
 
-      var code = child.accept(this);
+      var code = _visit(child);
       if (code != null) body.add(code);
     }
     // Flush any unwritten fields/properties.
     _flushLazyFields(body);
     _flushLibraryProperties(body);
     return _statement(body);
   }
 
   bool isPublic(String name) => !name.startsWith('_');
 
   /// Conversions that we don't handle end up here.
   @override
   visitConversion(Conversion node) {
     var from = node.baseType;
     var to = node.convertedType;
 
     // All Dart number types map to a JS double.
     if (rules.isNumType(from) &&
         (rules.isIntType(to) || rules.isDoubleType(to))) {
       // TODO(jmesserly): a lot of these checks are meaningless, as people use
       // `num` to mean "any kind of number" rather than "could be null".
       // The core libraries especially suffer from this problem, with many of
       // the `num` methods returning `num`.
       if (!rules.isNonNullableType(from) && rules.isNonNullableType(to)) {
         // Converting from a nullable number to a non-nullable number
         // only requires a null check.
-        return js.call('dart.notNull(#)', node.expression.accept(this));
+        return js.call('dart.notNull(#)', _visit(node.expression));
       } else {
         // A no-op in JavaScript.
-        return node.expression.accept(this);
+        return _visit(node.expression);
       }
     }
 
     return _emitCast(node.expression, to);
   }
 
   @override
   visitAsExpression(AsExpression node) =>
       _emitCast(node.expression, node.type.type);
 
   _emitCast(Expression node, DartType type) =>
-      js.call('dart.as(#)', [[node.accept(this), _emitTypeName(type)]]);
+      js.call('dart.as(#)', [[_visit(node), _emitTypeName(type)]]);
 
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
-    var lhs = node.expression.accept(this);
+    var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
     if (typeofName != null) {
       result = js.call('typeof # == #', [lhs, typeofName]);
     } else {
       // Always go through a runtime helper, because implicit interfaces.
       result = js.call('dart.is(#, #)', [lhs, _emitTypeName(type)]);
     }
 
     if (node.notOperator != null) {
       return js.call('!#', result);
@@ skipping 79 matching lines @@
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     if (ctors.isEmpty && !node.element.type.isObject) {
       jsMethods.add(_emitImplicitConstructor(node, name, fields));
     }
 
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         jsMethods.add(_emitConstructor(member, name, fields));
       } else if (member is MethodDeclaration) {
-        jsMethods.add(member.accept(this));
+        jsMethods.add(_visit(member));
       }
     }
 
     // Support for adapting dart:core Iterator/Iterable to ES6 versions.
     // This lets them use for-of loops transparently.
     // https://github.com/lukehoban/es6features#iterators--forof
     if (node.element.library.isDartCore && node.element.name == 'Iterable') {
       JS.Fun body = js.call('''function() {
         var iterator = this.iterator;
         return {
@@ skipping 70 matching lines @@
 
   JS.Method _emitConstructor(ConstructorDeclaration node, String className,
       List<FieldDeclaration> fields) {
     if (_externalOrNative(node)) return null;
 
     var name = _constructorName(className, node.name);
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
-    return new JS.Method(new JS.PropertyName(name), new JS.Fun(
-        node.parameters.accept(this), _emitConstructorBody(node, fields)));
+    return new JS.Method(new JS.PropertyName(name),
+        new JS.Fun(_visit(node.parameters), _emitConstructorBody(node, fields)))
+      ..sourceInformation = node;
   }
 
   String _constructorName(String className, SimpleIdentifier name) {
     if (name == null) return className;
     return '$className\$${name.name}';
   }
 
   JS.Block _emitConstructorBody(
       ConstructorDeclaration node, List<FieldDeclaration> fields) {
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     if (node.redirectedConstructor != null) {
       return js.statement('{ return new #(#); }', [
-        node.redirectedConstructor.accept(this),
-        node.parameters.accept(this)
+        _visit(node.redirectedConstructor),
+        _visit(node.parameters)
       ]);
     }
 
     var body = <JS.Statement>[];
 
     // Generate optional/named argument value assignment. These can not have
     // side effects, and may be used by the constructor's initializers, so it's
     // nice to do them first.
     var init = _emitArgumentInitializers(node.parameters);
     if (init != null) body.add(init);
 
     // Redirecting constructors: these are not allowed to have initializers,
     // and the redirecting ctor invocation runs before field initializers.
     var redirectCall = node.initializers.firstWhere(
         (i) => i is RedirectingConstructorInvocation, orElse: () => null);
 
     if (redirectCall != null) {
-      body.add(redirectCall.accept(this));
+      body.add(_visit(redirectCall));
       return new JS.Block(body);
     }
 
     // Initializers only run for non-factory constructors.
     if (node.factoryKeyword == null) {
       // Generate field initializers.
       // These are expanded into each non-redirecting constructor.
       // In the future we may want to create an initializer function if we have
       // multiple constructors, but it needs to be balanced against readability.
       body.add(_initializeFields(fields, node.parameters, node.initializers));
 
       var superCall = node.initializers.firstWhere(
           (i) => i is SuperConstructorInvocation, orElse: () => null);
 
       // If no superinitializer is provided, an implicit superinitializer of the
       // form `super()` is added at the end of the initializer list, unless the
       // enclosing class is class Object.
       var jsSuper = _superConstructorCall(node.parent, superCall);
       if (jsSuper != null) body.add(jsSuper);
     }
 
-    body.add(node.body.accept(this));
-    return new JS.Block(body);
+    body.add(_visit(node.body));
+    return new JS.Block(body)..sourceInformation = node;
   }
 
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     ClassDeclaration classDecl = node.parent.parent;
     var className = classDecl.name.name;
 
     var name = _constructorName(className, node.constructorName);
-    return js.statement('this.#(#);', [name, node.argumentList.accept(this)]);
+    return js.statement('this.#(#);', [name, _visit(node.argumentList)]);
   }
 
   JS.Statement _superConstructorCall(ClassDeclaration clazz,
       [SuperConstructorInvocation node]) {
     var superCtorName = node != null ? node.constructorName : null;
 
     var element = clazz.element;
     if (superCtorName == null &&
         (element.type.isObject || element.supertype.isObject)) {
       return null;
     }
 
     var supertypeName = element.supertype.name;
     var name = _constructorName(supertypeName, superCtorName);
 
-    var args = node != null ? node.argumentList.accept(this) : [];
-    return js.statement('super.#(#);', [name, args]);
+    var args = node != null ? _visit(node.argumentList) : [];
+    return js.statement('super.#(#);', [name, args])..sourceInformation = node;
   }
 
   /// Initialize fields. They follow the sequence:
   ///
   ///   1. field declaration initializer if non-const,
   ///   2. field initializing parameters,
   ///   3. constructor field initializers,
   ///   4. initialize fields not covered in 1-3
   JS.Statement _initializeFields(List<FieldDeclaration> fields,
       [FormalParameterList parameters,
       NodeList<ConstructorInitializer> initializers]) {
     var body = <JS.Statement>[];
 
     // Run field initializers if they can have side-effects.
     var unsetFields = new Map<String, VariableDeclaration>();
     for (var declaration in fields) {
       for (var field in declaration.fields.variables) {
         if (_isFieldInitConstant(field)) {
           unsetFields[field.name.name] = field;
         } else {
           body.add(js.statement(
-              '# = #;', [field.name.accept(this), _visitInitializer(field)]));
+              '# = #;', [_visit(field.name), _visitInitializer(field)]));
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (parameters != null) {
       for (var p in parameters.parameters) {
         if (p is DefaultFormalParameter) p = p.parameter;
         if (p is FieldFormalParameter) {
           var name = p.identifier.name;
           body.add(js.statement('this.# = #;', [name, name]));
           unsetFields.remove(name);
         }
       }
     }
 
     // Run constructor field initializers such as `: foo = bar.baz`
     if (initializers != null) {
       for (var init in initializers) {
         if (init is ConstructorFieldInitializer) {
-          body.add(js.statement('# = #;', [
-            init.fieldName.accept(this),
-            init.expression.accept(this)
-          ]));
+          body.add(js.statement(
+              '# = #;', [_visit(init.fieldName), _visit(init.expression)]));
           unsetFields.remove(init.fieldName.name);
         }
       }
     }
 
     // Initialize all remaining fields
     unsetFields.forEach((name, field) {
       JS.Expression value;
       if (field.initializer != null) {
-        value = field.initializer.accept(this);
+        value = _visit(field.initializer);
       } else {
         var type = rules.elementType(field.element);
         if (rules.maybeNonNullableType(type)) {
           value = js.call('dart.as(null, #)', _emitTypeName(type));
         } else {
           value = new JS.LiteralNull();
         }
       }
       body.add(js.statement('this.# = #;', [name, value]));
     });
@@ skipping 41 matching lines @@
           name,
           _defaultParamValue(param)
         ]));
       }
     }
     return _statement(body);
   }
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
-      return param.defaultValue.accept(this);
+      return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
   @override
   JS.Method visitMethodDeclaration(MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     return new JS.Method(new JS.PropertyName(_jsMethodName(node.name.name)),
-        new JS.Fun(params, node.body.accept(this)),
+        new JS.Fun(params, _visit(node.body)),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
       _properties.add(node);
       return null;
     }
 
     var body = <JS.Statement>[];
     _flushLibraryProperties(body);
 
     var name = node.name.name;
     body.add(js.comment('Function $name: ${node.element.type}'));
 
-    body.add(new JS.FunctionDeclaration(new JS.VariableDeclaration(name),
-        node.functionExpression.accept(this)));
+    body.add(new JS.FunctionDeclaration(
+        new JS.VariableDeclaration(name), _visit(node.functionExpression)));
 
     if (isPublic(name)) _exports.add(name);
     return _statement(body);
   }
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     if (isPublic(name)) _exports.add(name);
     return new JS.Method(
-        new JS.PropertyName(name), node.functionExpression.accept(this),
+        new JS.PropertyName(name), _visit(node.functionExpression),
         isGetter: node.isGetter, isSetter: node.isSetter);
   }
 
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     if (node.parent is FunctionDeclaration) {
-      return new JS.Fun(params, node.body.accept(this));
+      return new JS.Fun(params, _visit(node.body));
     } else {
       var bindThis = _maybeBindThis(node.body);
 
       String code;
       AstNode body;
       var nodeBody = node.body;
       if (nodeBody is ExpressionFunctionBody) {
         code = '(#) => #';
         body = nodeBody.expression;
       } else {
         code = '(#) => { #; }';
         body = nodeBody;
       }
-      return js.call('($code)$bindThis', [params, body.accept(this)]);
+      return js.call('($code)$bindThis', [params, _visit(body)]);
     }
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
 
     var name = new JS.VariableDeclaration(func.name.name);
     return new JS.Block([
       js.comment("// Function ${func.name.name}: ${func.element.type}\n"),
-      new JS.FunctionDeclaration(name, func.functionExpression.accept(this))
+      new JS.FunctionDeclaration(name, _visit(func.functionExpression))
     ]);
   }
 
   /// Writes a simple identifier. This can handle implicit `this` as well as
   /// going through the qualified library name if necessary.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
@@ skipping 48 matching lines @@
     var lhs = node.leftHandSide;
     var rhs = node.rightHandSide;
     if (lhs is IndexExpression) {
       String code;
       var target = _getTarget(lhs);
       if (rules.isDynamicTarget(target)) {
         code = 'dart.dsetindex(#, #, #)';
       } else {
         code = '#.set(#, #)';
       }
-      return js.call(code, [
-        target.accept(this),
-        lhs.index.accept(this),
-        rhs.accept(this)
-      ]);
+      return js.call(code, [_visit(target), _visit(lhs.index), _visit(rhs)]);
     }
 
     if (lhs is PropertyAccess) {
       var target = _getTarget(lhs);
       if (rules.isDynamicTarget(target)) {
         return js.call('dart.dput(#, #, #)', [
-          target.accept(this),
+          _visit(target),
           js.string(lhs.propertyName.name, "'"),
-          rhs.accept(this)
+          _visit(rhs)
         ]);
       }
     }
 
     if (node.parent is ExpressionStatement &&
         rhs is CascadeExpression &&
         _isStateless(lhs, rhs)) {
       // Special case: cascade assignment to a variable in a statement.
       // We can reuse the variable to desugar it:
       //    result = []..length = length;
       // becomes:
       //    result = [];
       //    result.length = length;
       var savedCascadeTemp = _cascadeTarget;
       _cascadeTarget = lhs;
 
       var body = [];
-      body.add(
-          js.statement('# = #;', [lhs.accept(this), rhs.target.accept(this)]));
+      body.add(js.statement('# = #;', [_visit(lhs), _visit(rhs.target)]));
       for (var section in rhs.cascadeSections) {
-        body.add(new JS.ExpressionStatement(section.accept(this)));
+        body.add(new JS.ExpressionStatement(_visit(section)));
       }
 
       _cascadeTarget = savedCascadeTemp;
       return _statement(body);
     }
 
-    return js.call('# = #', [lhs.accept(this), rhs.accept(this)]);
+    return js.call('# = #', [_visit(lhs), _visit(rhs)]);
   }
 
   @override
   JS.Block visitExpressionFunctionBody(ExpressionFunctionBody node) {
     var initArgs = _emitArgumentInitializers(_parametersOf(node.parent));
-    var ret = new JS.Return(node.expression.accept(this));
+    var ret = new JS.Return(_visit(node.expression));
     return new JS.Block(initArgs != null ? [initArgs, ret] : [ret]);
   }
 
   @override
   JS.Block visitEmptyFunctionBody(EmptyFunctionBody node) => new JS.Block([]);
 
   @override
   JS.Block visitBlockFunctionBody(BlockFunctionBody node) {
     var initArgs = _emitArgumentInitializers(_parametersOf(node.parent));
     var block = visitBlock(node.block);
     if (initArgs != null) return new JS.Block([initArgs, block]);
     return block;
   }
 
   @override
   JS.Block visitBlock(Block node) => new JS.Block(_visitList(node.statements));
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.isCascaded ? _cascadeTarget : node.target;
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     if (rules.isDynamicCall(node.methodName)) {
-      var args = node.argumentList.accept(this);
+      var args = _visit(node.argumentList);
       if (target != null) {
         return js.call('dart.dinvoke(#, #, #)', [
-          target.accept(this),
+          _visit(target),
           js.string(node.methodName.name, "'"),
           args
         ]);
       } else {
-        return js.call(
-            'dart.dinvokef(#, #)', [node.methodName.accept(this), args]);
+        return js.call('dart.dinvokef(#, #)', [_visit(node.methodName), args]);
       }
     }
 
     // TODO(jmesserly): if this resolves to a getter returning a function with
     // a call method, we don't generate the `.call` correctly.
 
     var targetJs;
     if (target != null) {
-      targetJs = js.call('#.#', [target.accept(this), node.methodName.name]);
+      targetJs = js.call('#.#', [_visit(target), node.methodName.name]);
     } else {
-      targetJs = node.methodName.accept(this);
+      targetJs = _visit(node.methodName);
     }
 
-    return js.call('#(#)', [targetJs, node.argumentList.accept(this)]);
+    return js.call('#(#)', [targetJs, _visit(node.argumentList)]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
     if (e is FunctionElement &&
         e.library.name == '_foreign_helper' &&
         e.name == 'JS') {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
@@ skipping 10 matching lines @@
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     var code;
     if (rules.isDynamicCall(node.function)) {
       code = 'dart.dinvokef(#, #)';
     } else {
       code = '#(#)';
     }
-    return js.call(
-        code, [node.function.accept(this), node.argumentList.accept(this)]);
+    return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
   }
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
     for (var arg in node.arguments) {
       if (arg is NamedExpression) {
         named.add(visitNamedExpression(arg));
       } else {
-        args.add(arg.accept(this));
+        args.add(_visit(arg));
       }
     }
     if (named.isNotEmpty) {
       args.add(new JS.ObjectInitializer(named));
     }
     return args;
   }
 
   @override
   JS.Property visitNamedExpression(NamedExpression node) {
     assert(node.parent is ArgumentList);
-    return new JS.Property(new JS.PropertyName(node.name.label.name),
-        node.expression.accept(this));
+    return new JS.Property(
+        new JS.PropertyName(node.name.label.name), _visit(node.expression));
   }
 
   @override
   List<JS.Parameter> visitFormalParameterList(FormalParameterList node) {
     var result = <JS.Parameter>[];
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
         result.add(new JS.Parameter(_jsNamedParameterName));
         break;
       }
       result.add(new JS.Parameter(param.identifier.name));
     }
     return result;
   }
 
   @override
   JS.Statement visitExpressionStatement(ExpressionStatement node) =>
-      _expressionStatement(node.expression.accept(this));
+      _expressionStatement(_visit(node.expression));
 
   // Some expressions may choose to generate themselves as JS statements
   // if their parent is in a statement context.
   // TODO(jmesserly): refactor so we handle the special cases here, and
   // can use better return types on the expression visit methods.
   JS.Statement _expressionStatement(expr) =>
       expr is JS.Statement ? expr : new JS.ExpressionStatement(expr);
 
   @override
   JS.EmptyStatement visitEmptyStatement(EmptyStatement node) =>
       new JS.EmptyStatement();
 
   @override
   JS.Statement visitAssertStatement(AssertStatement node) =>
       // TODO(jmesserly): only emit in checked mode.
-      js.statement('dart.assert(#);', node.condition.accept(this));
+      js.statement('dart.assert(#);', _visit(node.condition));
 
   @override
   JS.Return visitReturnStatement(ReturnStatement node) =>
       new JS.Return(_visit(node.expression));
 
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     var body = <JS.Statement>[];
 
     for (var field in node.variables.variables) {
       if (field.isConst) {
         // constant fields don't change, so we can generate them as `let`
         // but add them to the module's exports
         var name = field.name.name;
         body.add(js.statement('let # = #;', [
           new JS.VariableDeclaration(name),
           _visitInitializer(field)
         ]));
         if (isPublic(name)) _exports.add(name);
       } else if (_isFieldInitConstant(field)) {
         body.add(js.statement(
-            '# = #;', [field.name.accept(this), _visitInitializer(field)]));
+            '# = #;', [_visit(field.name), _visitInitializer(field)]));
       } else {
         _lazyFields.add(field);
       }
     }
 
     return _statement(body);
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     var last = node.variables.last;
     var lastInitializer = last.initializer;
 
     List<JS.VariableInitialization> variables;
     if (lastInitializer is CascadeExpression &&
         node.parent is VariableDeclarationStatement) {
       // Special case: cascade as variable initializer
       //
       // We can reuse the variable to desugar it:
       //    var result = []..length = length;
       // becomes:
       //    var result = [];
       //    result.length = length;
       var savedCascadeTemp = _cascadeTarget;
       _cascadeTarget = last.name;
 
       variables = _visitList(node.variables.take(node.variables.length - 1));
       variables.add(new JS.VariableInitialization(
           new JS.VariableDeclaration(last.name.name),
-          lastInitializer.target.accept(this)));
+          _visit(lastInitializer.target)));
 
       var result = <JS.Expression>[
         new JS.VariableDeclarationList('let', variables)
       ];
       result.addAll(_visitList(lastInitializer.cascadeSections));
       _cascadeTarget = savedCascadeTemp;
       return _statement(result.map((e) => new JS.ExpressionStatement(e)));
     } else {
       variables = _visitList(node.variables);
     }
@@ skipping 21 matching lines @@
   }
 
   JS.Statement _emitLazyFields(
       String objExpr, List<VariableDeclaration> fields) {
     if (fields.isEmpty) return null;
 
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       methods.add(new JS.Method(new JS.PropertyName(name),
-          js.call('function() { return #; }', node.initializer.accept(this)),
+          js.call('function() { return #; }', _visit(node.initializer)),
           isGetter: true));
 
       // TODO(jmesserly): use a dummy setter to indicate writable.
       if (!node.isFinal) {
         methods.add(new JS.Method(
             new JS.PropertyName(name), js.call('function() {}'),
             isSetter: true));
       }
     }
 
     return js.statement(
         'dart.defineLazyProperties(#, { # })', [objExpr, methods]);
   }
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
     body.add(js.statement('dart.copyProperties(#, { # });', [
       _libraryName,
       _properties.map(_emitTopLevelProperty)
     ]));
     _properties.clear();
   }
 
   @override
   JS.Statement visitVariableDeclarationStatement(
           VariableDeclarationStatement node) =>
-      _expressionStatement(node.variables.accept(this));
+      _expressionStatement(_visit(node.variables));
 
   @override
   visitConstructorName(ConstructorName node) {
-    var typeName = node.type.name.accept(this);
+    var typeName = _visit(node.type.name);
     if (node.name != null) {
       return js.call('#.#', [typeName, node.name.name]);
     }
     return typeName;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
-    return js.call('new #(#)', [
-      node.constructorName.accept(this),
-      node.argumentList.accept(this)
-    ]);
+    return js.call(
+        'new #(#)', [_visit(node.constructorName), _visit(node.argumentList)]);
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
   bool _isJSBuiltinType(DartType t) =>
       rules.isNumType(t) || rules.isStringType(t) || rules.isBoolType(t);
 
   bool typeIsPrimitiveInJS(DartType t) => !rules.isDynamic(t) &&
       (rules.isIntType(t) ||
           rules.isDoubleType(t) ||
           rules.isBoolType(t) ||
           rules.isNumType(t));
 
   bool typeIsNonNullablePrimitiveInJS(DartType t) =>
       typeIsPrimitiveInJS(t) && rules.isNonNullableType(t);
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   JS.Expression notNull(Expression expr) {
     var type = rules.getStaticType(expr);
     if (rules.isNonNullableType(type)) {
-      return expr.accept(this);
+      return _visit(expr);
     } else {
-      return js.call('dart.notNull(#)', expr.accept(this));
+      return js.call('dart.notNull(#)', _visit(expr));
     }
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
     var leftType = rules.getStaticType(left);
     var rightType = rules.getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if the left hand side is a primitive type, because
       // we know then it doesn't have an overridden.
       if (_isNull(left) || _isNull(right) || typeIsPrimitiveInJS(leftType)) {
         // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-strict-equality-comparison
         code = op.type == TokenType.EQ_EQ ? '# === #' : '# !== #';
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
-      return js.call(code, [left.accept(this), right.accept(this)]);
+      return js.call(code, [_visit(left), _visit(right)]);
     } else if (binaryOperationIsPrimitive(leftType, rightType)) {
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         code = '(# / #).truncate()';
       } else {
         // TODO(vsm): When do Dart ops not map to JS?
         code = '# $op #';
       }
       return js.call(code, [notNull(left), notNull(right)]);
     } else {
       var opString = js.string(op.lexeme, "'");
       if (rules.isDynamicTarget(left)) {
         // dynamic dispatch
-        return js.call('dart.dbinary(#, #, #)', [
-          left.accept(this),
-          opString,
-          right.accept(this)
-        ]);
+        return js.call(
+            'dart.dbinary(#, #, #)', [_visit(left), opString, _visit(right)]);
       } else if (_isJSBuiltinType(leftType)) {
         // TODO(jmesserly): we'd get better readability from the static-dispatch
         // pattern below. Consider:
         //
         //     "hello"['+']"world"
         // vs
         //     core.String['+']("hello", "world")
         //
         // Infix notation is much more readable, which is a bit part of why
         // C# added its extension methods feature. However this would require
         // adding these methods to String.prototype/Number.prototype in JS.
         return js.call('#.#(#, #)', [
           _emitTypeName(leftType),
           opString,
-          left.accept(this),
-          right.accept(this)
+          _visit(left),
+          _visit(right)
         ]);
       } else {
         // Generic static-dispatch, user-defined operator code path.
-        return js.call(
-            '#.#(#)', [left.accept(this), opString, right.accept(this)]);
+        return js.call('#.#(#)', [_visit(left), opString, _visit(right)]);
       }
     }
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
@@ skipping 36 matching lines @@
       // Special case: target is stateless, so we can just reuse it.
       _cascadeTarget = node.target;
 
       if (parent is ExpressionStatement) {
         var sections = _visitList(node.cascadeSections);
         result = _statement(sections.map((e) => new JS.ExpressionStatement(e)));
       } else {
         // Use comma expression. For example:
         //    (sb.write(1), sb.write(2), sb)
         var sections = _visitListToBinary(node.cascadeSections, ',');
-        result = new JS.Binary(',', sections, _cascadeTarget.accept(this));
+        result = new JS.Binary(',', sections, _visit(_cascadeTarget));
       }
     } else {
       // In the general case we need to capture the target expression into
       // a temporary. This uses a lambda to get a temporary scope, and it also
       // remains valid in an expression context.
       // TODO(jmesserly): need a better way to handle temps.
       // TODO(jmesserly): special case for parent is ExpressionStatement?
       _cascadeTarget =
           new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '_', 0));
       _cascadeTarget.staticElement =
           new LocalVariableElementImpl.forNode(_cascadeTarget);
       _cascadeTarget.staticType = node.target.staticType;
 
       var body = _visitList(node.cascadeSections);
       if (node.parent is! ExpressionStatement) {
         body.add(js.statement('return #;', _cascadeTarget.name));
       }
 
       var bindThis = _maybeBindThis(node.cascadeSections);
       result = js.call('((#) => { # })$bindThis(#)', [
         _cascadeTarget.name,
         body,
-        node.target.accept(this)
+        _visit(node.target)
       ]);
     }
 
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
   /// True is the expression can be evaluated multiple times without causing
   /// code execution. This is true for final fields. This can be true for local
   /// variables, if:
@@ skipping 10 matching lines @@
           return !_isPotentiallyMutated(e, context);
         }
       }
     }
     return false;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
-      node.expression.accept(this);
+      _visit(node.expression);
 
   @override
   visitSimpleFormalParameter(SimpleFormalParameter node) =>
-      node.identifier.accept(this);
+      _visit(node.identifier);
 
   @override
   visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
-      node.identifier.accept(this);
+      _visit(node.identifier);
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.prefix.staticElement is PrefixElement) {
-      return node.identifier.accept(this);
+      return _visit(node.identifier);
     } else {
       return _visitGet(node.prefix, node.identifier);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
       _visitGet(_getTarget(node), node.propertyName);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   _visitGet(Expression target, SimpleIdentifier name) {
     if (rules.isDynamicTarget(target)) {
       return js.call(
-          'dart.dload(#, #)', [target.accept(this), js.string(name.name, "'")]);
+          'dart.dload(#, #)', [_visit(target), js.string(name.name, "'")]);
     } else {
-      return js.call('#.#', [target.accept(this), name.name]);
+      return js.call('#.#', [_visit(target), name.name]);
     }
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
     var code;
     if (rules.isDynamicTarget(target)) {
       code = 'dart.dindex(#, #)';
     } else {
       code = '#.get(#)';
     }
-    return js.call(code, [target.accept(this), node.index.accept(this)]);
+    return js.call(code, [_visit(target), _visit(node.index)]);
   }
 
   /// Gets the target of a [PropertyAccess] or [IndexExpression].
   /// Those two nodes are special because they're both allowed on left side of
   /// an assignment expression and cascades.
   Expression _getTarget(node) {
     assert(node is IndexExpression || node is PropertyAccess);
     return node.isCascaded ? _cascadeTarget : node.target;
   }
 
   @override
   visitConditionalExpression(ConditionalExpression node) {
     return js.call('# ? # : #', [
-      node.condition.accept(this),
-      node.thenExpression.accept(this),
-      node.elseExpression.accept(this)
+      _visit(node.condition),
+      _visit(node.thenExpression),
+      _visit(node.elseExpression)
     ]);
   }
 
   @override
   visitThrowExpression(ThrowExpression node) {
-    var expr = node.expression.accept(this);
+    var expr = _visit(node.expression);
     if (node.parent is ExpressionStatement) {
       return js.statement('throw #;', expr);
     } else {
       return js.call('dart.throw_(#)', expr);
     }
   }
 
   @override
   JS.If visitIfStatement(IfStatement node) {
-    return new JS.If(node.condition.accept(this), _visit(node.thenStatement),
+    return new JS.If(_visit(node.condition), _visit(node.thenStatement),
         _visitOrEmpty(node.elseStatement));
   }
 
   @override
   JS.For visitForStatement(ForStatement node) {
     var init = _visit(node.initialization);
     if (init == null) init = _visit(node.variables);
     return new JS.For(init, _visit(node.condition),
         _visitListToBinary(node.updaters, ','), _visit(node.body));
   }
 
   @override
   JS.While visitWhileStatement(WhileStatement node) {
-    return new JS.While(node.condition.accept(this), node.body.accept(this));
+    return new JS.While(_visit(node.condition), _visit(node.body));
   }
 
   @override
   JS.Do visitDoStatement(DoStatement node) {
-    return new JS.Do(node.body.accept(this), node.condition.accept(this));
+    return new JS.Do(_visit(node.body), _visit(node.condition));
   }
 
   @override
   JS.ForOf visitForEachStatement(ForEachStatement node) {
     var init = _visit(node.identifier);
     if (init == null) {
       init = js.call('let #', node.loopVariable.identifier.name);
     }
-    return new JS.ForOf(
-        init, node.iterable.accept(this), node.body.accept(this));
+    return new JS.ForOf(init, _visit(node.iterable), _visit(node.body));
   }
 
   @override
   visitBreakStatement(BreakStatement node) {
     var label = node.label;
     return new JS.Break(label != null ? label.name : null);
   }
 
   @override
   visitContinueStatement(ContinueStatement node) {
@@ skipping 33 matching lines @@
     if (s.length == 0) return new JS.Block([]);
     if (s.length == 1) return s[0];
     return new JS.Block(s);
   }
 
   JS.Statement _visitCatchClause(CatchClause node, String varName) {
     var body = [];
     if (node.catchKeyword != null) {
       var name = node.exceptionParameter;
       if (name != null && name.name != varName) {
-        body.add(js.statement('let # = #;', [name.accept(this), varName]));
+        body.add(js.statement('let # = #;', [_visit(name), varName]));
       }
       if (node.stackTraceParameter != null) {
         var stackVar = node.stackTraceParameter.name;
         body.add(js.statement(
-            'let # = dart.stackTrace(#);', [stackVar, name.accept(this)]));
+            'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
       }
     }
 
-    body.add(node.body.accept(this));
+    body.add(_visit(node.body));
 
     if (node.exceptionType != null) {
       return js.statement('if (dart.is(#, #)) #;', [
         varName,
         _emitTypeName(node.exceptionType.type),
         _statement(body)
       ]);
     }
     return _statement(body);
   }
 
   @override
   JS.Case visitSwitchCase(SwitchCase node) {
-    var expr = node.expression.accept(this);
+    var expr = _visit(node.expression);
     var body = _visitList(node.statements);
     if (node.labels.isNotEmpty) {
       body.insert(0, js.comment('Unimplemented case labels: ${node.labels}'));
     }
     // TODO(jmesserly): make sure we are statically checking fall through
     return new JS.Case(expr, new JS.Block(body));
   }
 
   @override
   JS.Default visitSwitchDefault(SwitchDefault node) {
     var body = _visitList(node.statements);
     if (node.labels.isNotEmpty) {
       body.insert(0, js.comment('Unimplemented case labels: ${node.labels}'));
     }
     // TODO(jmesserly): make sure we are statically checking fall through
     return new JS.Default(new JS.Block(body));
   }
 
   @override
   JS.Switch visitSwitchStatement(SwitchStatement node) =>
-      new JS.Switch(node.expression.accept(this), _visitList(node.members));
+      new JS.Switch(_visit(node.expression), _visitList(node.members));
 
   @override
   JS.Statement visitLabeledStatement(LabeledStatement node) {
     var result = _visit(node.statement);
     for (var label in node.labels.reversed) {
       result = new JS.LabeledStatement(label.label.name, result);
     }
     return result;
   }
 
@@ skipping 22 matching lines @@
   visitMapLiteral(MapLiteral node) {
     var entries = node.entries;
     var mapArguments = null;
     if (entries.isEmpty) return js.call('dart.map()');
 
     // Use JS object literal notation if possible, otherwise use an array.
     if (entries.every((e) => e.key is SimpleStringLiteral)) {
       var props = [];
       for (var e in entries) {
         var key = (e.key as SimpleStringLiteral).value;
-        var value = e.value.accept(this);
+        var value = _visit(e.value);
         props.add(new JS.Property(js.escapedString(key), value));
       }
       mapArguments = new JS.ObjectInitializer(props);
     } else {
       var values = [];
       for (var e in entries) {
-        values.add(e.key.accept(this));
-        values.add(e.value.accept(this));
+        values.add(_visit(e.key));
+        values.add(_visit(e.value));
       }
       mapArguments = new JS.ArrayInitializer(values);
     }
     return js.call('dart.map(#)', [mapArguments]);
   }
 
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
 
@@ skipping 11 matching lines @@
 
   @override
   String visitInterpolationString(InterpolationString node) {
     // TODO(jmesserly): this call adds quotes, and then we strip them off.
     var str = js.escapedString(node.value, '`').value;
     return str.substring(1, str.length - 1);
   }
 
   @override
   visitInterpolationExpression(InterpolationExpression node) =>
-      node.expression.accept(this);
+      _visit(node.expression);
 
   @override
   visitBooleanLiteral(BooleanLiteral node) => js.boolean(node.value);
 
   @override
   JS.Statement visitDeclaration(Declaration node) =>
       js.comment('Unimplemented ${node.runtimeType}: $node');
 
   @override
   JS.Statement visitStatement(Statement node) =>
@@ skipping 38 matching lines @@
 
   /// Returns true if [element] is a getter in JS, therefore needs
   /// `lib.topLevel` syntax instead of just `topLevel`.
   bool _needsModuleGetter(Element element) {
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     return element is TopLevelVariableElement && !element.isConst;
   }
 
-  _visit(AstNode node) => node != null ? node.accept(this) : null;
+  _visit(AstNode node) {
+    if (node == null) return null;
+    var result = node.accept(this);
+    if (result is JS.Node) result.sourceInformation = node;
+    return result;
+  }
 
-  JS.Statement _visitOrEmpty(AstNode node) {
+  JS.Statement _visitOrEmpty(Statement node) {
     if (node == null) return new JS.EmptyStatement();
-    return node.accept(this);
+    return _visit(node);
   }
 
   List _visitList(Iterable<AstNode> nodes) {
     if (nodes == null) return null;
     var result = [];
-    for (var node in nodes) result.add(node.accept(this));
+    for (var node in nodes) result.add(_visit(node));
     return result;
   }
 
   /// Visits a list of expressions, creating a comma expression if needed in JS.
   JS.Expression _visitListToBinary(List<Expression> nodes, String operator) {
     if (nodes == null || nodes.isEmpty) return null;
 
     JS.Expression result = null;
     for (var node in nodes) {
-      var jsExpr = node.accept(this);
+      var jsExpr = _visit(node);
       if (result == null) {
         result = jsExpr;
       } else {
         result = new JS.Binary(operator, result, jsExpr);
       }
     }
     return result;
   }
 
   /// The following names are allowed for user-defined operators:
@@ skipping 101 matching lines @@
     }
   }
 
   @override
   visitThisExpression(ThisExpression node) {
     _bindThis = true;
   }
 }
 
 class JSGenerator extends CodeGenerator {
-  JSGenerator(String outDir, Uri root, TypeRules rules)
+  final JSCodeOptions options;
+
+  JSGenerator(String outDir, Uri root, TypeRules rules, this.options)
       : super(outDir, root, rules);
 
   void generateLibrary(Iterable<CompilationUnit> units, LibraryInfo info,
       CheckerReporter reporter) {
     JS.Block jsTree =
         new JSCodegenVisitor(info, rules).generateLibrary(units, reporter);
 
     var outputPath = path.join(outDir, jsOutputPath(info));
     new Directory(path.dirname(outputPath)).createSync(recursive: true);
 
-    var context = new JS.SimpleJavaScriptPrintingContext();
+    if (options.emitSourceMaps) {
+      var outFilename = path.basename(outputPath);
+      var printer = new srcmaps.Printer(outFilename);
+      var context =
+          new SourceMapPrintingContext(printer, path.dirname(outputPath));
+      _writeLibrary(context, jsTree);
+      printer.add('//# sourceMappingURL=$outFilename.map');
+      // Write output file and source map
+      new File(outputPath).writeAsStringSync(printer.text);
+      new File('$outputPath.map').writeAsStringSync(printer.map);
+    } else {
+      var context = new JS.SimpleJavaScriptPrintingContext();
+      _writeLibrary(context, jsTree);
+      // Write output file and source map
+      new File(outputPath).writeAsStringSync(context.getText());
+    }
+  }
+
+  void _writeLibrary(JS.JavaScriptPrintingContext context, JS.Block jsTree) {
     var opts =
         new JS.JavaScriptPrintingOptions(avoidKeywordsInIdentifiers: true);
-    var printer = new JS.Printer(opts, context);
-    printer.blockOutWithoutBraces(jsTree);
-    new File(outputPath).writeAsStringSync(context.getText());
+    new JS.Printer(opts, context).blockOutWithoutBraces(jsTree);
   }
 }
 
+/// This is a debugging helper to print a JS node.
+String debugJsNodeToString(JS.Node node) {
+  var context = new JS.SimpleJavaScriptPrintingContext();
+  var opts = new JS.JavaScriptPrintingOptions(avoidKeywordsInIdentifiers: true);
+  new JS.Printer(opts, context).visit(node);
+  // Write output file and source map
+  return context.getText();
+}
+
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Path to file that will be generated for [info].
 // TODO(jmesserly): library directory should be relative to its package
 // root. For example, "package:dev_compiler/src/codegen/js_codegen.dart" would be:
 // "ddc/src/codegen/js_codegen.js" under the output directory.
 String jsOutputPath(LibraryInfo info) => '${info.name}/${info.name}.js';
+
+class SourceMapPrintingContext extends JS.JavaScriptPrintingContext {
+  final srcmaps.Printer printer;
+  final String outputDir;
+
+  CompilationUnit unit;
+  Uri uri;
+
+  SourceMapPrintingContext(this.printer, this.outputDir);
+
+  void emit(String string) {
+    printer.add(string);
+  }
+
+  void enterNode(JS.Node jsNode) {
+    AstNode node = jsNode.sourceInformation;
+    if (node is CompilationUnit) {
+      unit = node;
+      uri = _makeRelativeUri(unit.element.source.uri);
+      return;
+    }
+    if (unit == null || node == null || node.offset == -1) return;
+
+    var loc = _location(node.offset);
+    var name = _getIdentifier(node);
+    if (name != null) {
+      // TODO(jmesserly): mark only uses the beginning of the span, but
+      // we're required to pass this as a valid span.
+      var end = _location(node.end);
+      printer.mark(new SourceMapSpan(loc, end, name, isIdentifier: true));

[Siggi Cherem (dart-lang), 2015/02/27 23:26:23]

btw - I just realized this, in reporter.dart we do compute these using
SourceFile... we could switch there to do a similar trick as you do here, or if
possible, put the logic in a shared place (utils.dart?)

[Jennifer Messerly, 2015/02/27 23:30:45]

yes probably :)
opened https://github.com/dart-lang/dev_compiler/issues/73

+    } else {
+      printer.mark(loc);
+    }
+  }
+
+  SourceLocation _location(int offset) {
+    var lineInfo = unit.lineInfo.getLocation(offset);
+    return new SourceLocation(offset,
+        sourceUrl: uri,
+        line: lineInfo.lineNumber - 1,
+        column: lineInfo.columnNumber - 1);
+  }
+
+  Uri _makeRelativeUri(Uri src) {
+    return new Uri(path: path.relative(src.path, from: outputDir));
+  }
+
+  void exitNode(JS.Node jsNode) {
+    AstNode node = jsNode.sourceInformation;
+    if (node is CompilationUnit) {
+      unit = null;
+      uri = null;
+      return;
+    }
+    if (unit == null || node == null || node.offset == -1) return;
+
+    // TODO(jmesserly): in many cases marking the end will be unncessary.
+    printer.mark(_location(node.end));
+  }
+
+  String _getIdentifier(AstNode node) {
+    if (node is SimpleIdentifier) return node.name;
+    return null;
+  }
+}