Type annotations instead of closure comments.

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 js_codegen;
+
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 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/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/generated/type_system.dart'
@@ skipping 19 matching lines @@
 import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_names.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'module_builder.dart';
 import 'nullability_inferrer.dart';
 import 'side_effect_analysis.dart';
 
+part 'js_typeref_codegen.dart';
+
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // _runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
-class JSCodegenVisitor extends GeneralizingAstVisitor with ClosureAnnotator {
+class JSCodegenVisitor extends GeneralizingAstVisitor
+    with ClosureAnnotator, JsTypeRefCodegen {
   final AbstractCompiler compiler;
   final CodegenOptions options;
   final LibraryElement currentLibrary;
   final StrongTypeSystemImpl rules;
 
   /// The global extension type table.
   final HashSet<ClassElement> _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
@@ skipping 274 matching lines @@
     if (t == _types.boolType) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     var element = node.element;
     var type = element.type;
     var name = element.name;
 
-    var fnType = annotateTypeDef(
+    var fnType = annotate(
         js.statement('const # = dart.typedef(#, () => #);', [
           name,
           js.string(name, "'"),
           _emitTypeName(type, lowerTypedef: true)
         ]),
+        node,
         node.element);
 
     return _finishClassDef(type, fnType);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
@@ skipping 49 matching lines @@
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       } else if (member is MethodDeclaration) {
         methods.add(member);
       }
     }
 
-    var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
-        _classHeritage(classElem), _emitClassMethods(node, ctors, fields));
+    var classExpr = new JS.ClassExpression(
+        new JS.Identifier(type.name),
+        _classHeritage(classElem),
+        _emitClassMethods(node, ctors, fields),
+        _emitTypeArgs(classElem).toList(),
+        _emitFieldDeclarations(classElem, fields, staticFields).toList());
 
     String jsPeerName;
     var jsPeer = findAnnotation(classElem, isJsPeerInterface);
     if (jsPeer != null) {
       jsPeerName =
           getConstantField(jsPeer, 'name', types.stringType)?.toStringValue();
     }
 
     var body = _finishClassMembers(classElem, classExpr, ctors, fields,
         staticFields, methods, node.metadata, jsPeerName);
@@ skipping 12 matching lines @@
       // want to support construction of instances with generic types other
       // than dynamic. See issue #154 for Array and List<E> related bug.
       var copyMembers = js.statement(
           'dart.registerExtension(dart.global.#, #);',
           [_propertyName(jsPeerName), classElem.name]);
       return _statement([result, copyMembers]);
     }
     return result;
   }
 
+  Iterable<JS.Identifier> _emitTypeArgs(TypeParameterizedElement e) sync* {
+    if (!options.closure) return;
+    for (var typeParam in e.typeParameters) {
+      yield new JS.Identifier(typeParam.name);
+    }
+  }
+
+  /// Emit field declarations for TypeScript & Closure's ES6_TYPED
+  /// (e.g. `class Foo { i: string; }`)
+  Iterable<JS.VariableDeclarationList> _emitFieldDeclarations(
+      ClassElement classElem,
+      List<FieldDeclaration> fields,
+      List<FieldDeclaration> staticFields) sync* {
+    if (!options.closure) return;
+
+    makeInitialization(VariableDeclaration decl) =>
+        new JS.VariableInitialization(
+            new JS.Identifier(
+                // TODO(ochafik): use a refactored _emitMemberName instead.
+                decl.name.name,
+                type: emitTypeRef(decl.element.type)),
+            null);
+
+    for (var field in fields) {
+      yield new JS.VariableDeclarationList(
+          null, field.fields.variables.map(makeInitialization).toList());
+    }
+    for (var field in staticFields) {
+      yield new JS.VariableDeclarationList(
+          'static', field.fields.variables.map(makeInitialization).toList());
+    }
+  }
+
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) {
     var element = node.element;
     var type = element.type;
     var name = js.string(type.name);
     var id = new JS.Identifier(type.name);
 
     // Generate a class per section 13 of the spec.
     // TODO(vsm): Generate any accompanying metadata
 
@@ skipping 212 matching lines @@
           node.selector is JS.LiteralString;
 
   /// Workaround for Closure: super classes must be qualified paths.
   JS.Statement _emitClassHeritageWorkaround(JS.ClassExpression cls) {
     if (options.closure &&
         cls.heritage != null &&
         !_isQualifiedPath(cls.heritage)) {
       var superVar = new JS.TemporaryId(cls.name.name + r'$super');
       return _statement([
         js.statement('const # = #;', [superVar, cls.heritage]),
-        new JS.ClassDeclaration(
-            new JS.ClassExpression(cls.name, superVar, cls.methods))
+        new JS.ClassDeclaration(new JS.ClassExpression(
+            cls.name, superVar, cls.methods, cls.typeArgs, cls.fields))
       ]);
     }
     return new JS.ClassDeclaration(cls);
   }
 
   /// Emit class members that need to come after the class declaration, such
   /// as static fields. See [_emitClassMethods] for things that are emitted
   /// inside the ES6 `class { ... }` node.
   JS.Statement _finishClassMembers(
       ClassElement classElem,
@@ skipping 224 matching lines @@
     var superCall = _superConstructorCall(node.element);
     if (fields.isEmpty && superCall == null) return null;
 
     dynamic body = _initializeFields(node, fields);
     if (superCall != null) {
       body = [
         [body, superCall]
       ];
     }
     var name = _constructorName(node.element.unnamedConstructor);
-    return annotateDefaultConstructor(
+    return annotate(
         new JS.Method(name, js.call('function() { #; }', body) as JS.Fun),
+        node,
         node.element);
   }
 
   JS.Method _emitConstructor(ConstructorDeclaration node, InterfaceType type,
       List<FieldDeclaration> fields, bool isObject) {
     if (_externalOrNative(node)) return null;
 
     var name = _constructorName(node.element);
+    var returnType = emitTypeRef(node.element.enclosingElement.type);
 
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     var redirect = node.redirectedConstructor;
     if (redirect != null) {
       var newKeyword = redirect.staticElement.isFactory ? '' : 'new';
       // Pass along all arguments verbatim, and let the callee handle them.
       // TODO(jmesserly): we'll need something different once we have
       // rest/spread support, but this should work for now.
       var params =
           _emitFormalParameterList(node.parameters, allowDestructuring: false);
 
-      var fun = js.call('function(#) { return $newKeyword #(#); }',
-          [params, _visit(redirect), params]) as JS.Fun;
+      var fun = new JS.Fun(
+          params,
+          js.statement(
+              '{ return $newKeyword #(#); }', [_visit(redirect), params]),
+          returnType: returnType);
       return annotate(
-          new JS.Method(name, fun, isStatic: true)..sourceInformation = node,
-          node.element);
+          new JS.Method(name, fun, isStatic: true), node, node.element);
     }
 
     // Factory constructors are essentially static methods.
     if (node.factoryKeyword != null) {
       var body = <JS.Statement>[];
       var init = _emitArgumentInitializers(node, constructor: true);
       if (init != null) body.add(init);
       body.add(_visit(node.body));
       var fun = new JS.Fun(
-          _visit(node.parameters) as List<JS.Parameter>, new JS.Block(body));
+          _visit(node.parameters) as List<JS.Parameter>, new JS.Block(body),
+          returnType: returnType);
       return annotate(
-          new JS.Method(name, fun, isStatic: true)..sourceInformation = node,
-          node.element);
+          new JS.Method(name, fun, isStatic: true), node, node.element);
     }
 
     // Code generation for Object's constructor.
     JS.Block body;
     if (isObject &&
         node.body is EmptyFunctionBody &&
         node.constKeyword != null &&
         node.name == null) {
       // Implements Dart constructor behavior. Because of V8 `super`
       // [constructor restrictions]
@@ skipping 15 matching lines @@
         return result === void 0 ? this : result;
       }''') as JS.Block;
     } else {
       body = _emitConstructorBody(node, fields);
     }
 
     // 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 annotate(
-        new JS.Method(name,
-            new JS.Fun(_visit(node.parameters) as List<JS.Parameter>, body))
-          ..sourceInformation = node,
+        new JS.Method(
+            name,
+            new JS.Fun(_visit(node.parameters) as List<JS.Parameter>, body,
+                returnType: returnType)),
+        node,
         node.element);
   }
 
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
     if (name != '') {
       return _emitMemberName(name, isStatic: true);
     }
 
     // Factory default constructors use `new` as their name, for readability
@@ skipping 76 matching lines @@
 
     if (superCtor == null) {
       print('Error generating: ${element.displayName}');
     }
     if (superCtor.name == '' && !_shouldCallUnnamedSuperCtor(element)) {
       return null;
     }
 
     var name = _constructorName(superCtor);
     var args = node != null ? _visit(node.argumentList) : [];
-    return js.statement('super.#(#);', [name, args])..sourceInformation = node;
+    return annotate(js.statement('super.#(#);', [name, args]), node);
   }
 
   bool _shouldCallUnnamedSuperCtor(ClassElement e) {
     var supertype = e.supertype;
     if (supertype == null) return false;
     if (_hasUnnamedConstructor(supertype.element)) return true;
     for (var mixin in e.mixins) {
       if (_hasUnnamedConstructor(mixin.element)) return true;
     }
     return false;
@@ skipping 31 matching lines @@
           fields[element as FieldElement] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (ctor != null) {
       for (var p in ctor.parameters.parameters) {
         var element = p.element;
         if (element is FieldFormalParameterElement) {
-          fields[element.field] = _visit(p);
+          fields[element.field] = _emitFormalParameter(p, allowType: false);
         }
       }
 
       // Run constructor field initializers such as `: foo = bar.baz`
       for (var init in ctor.initializers) {
         if (init is ConstructorFieldInitializer) {
           fields[init.fieldName.staticElement as FieldElement] =
               _visit(init.expression);
         }
       }
@@ skipping 35 matching lines @@
   /// Emits argument initializers, which handles optional/named args, as well
   /// as generic type checks needed due to our covariance.
   JS.Statement _emitArgumentInitializers(node, {bool constructor: false}) {
     // Constructor argument initializers are emitted earlier in the code, rather
     // than always when we visit the function body, so we control it explicitly.
     if (node is ConstructorDeclaration != constructor) return null;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
+    var destructure = _canDestructureParams(parameters);
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
-      var jsParam = _visit(param.identifier);
+      var jsParam = _emitSimpleIdentifier(param.identifier, allowType: false);
 
       if (param.kind == ParameterKind.NAMED) {
-        if (!_isDestructurableNamedParam(param)) {
+        if (!destructure) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
 
           // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
           body.add(js.statement('let # = # && # in # ? #.# : #;', [
             jsParam,
             _namedArgTemp,
             paramName,
             _namedArgTemp,
@@ skipping 34 matching lines @@
   }
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
 
-    JS.Fun fn = _emitFunctionBody(params, node.body);
+    var typeArgs = _emitTypeArgs(node.element).toList();
+    var returnType = emitTypeRef(node.element.returnType);
+    JS.Fun fn = _emitFunctionBody(params, node.body, typeArgs, returnType);
     if (node.operatorKeyword != null &&
         node.name.name == '[]=' &&
         params.isNotEmpty) {
       // []= methods need to return the value. We could also address this at
       // call sites, but it's cleaner to instead transform the operator method.
       var returnValue = new JS.Return(params.last);
       var body = fn.body;
       if (JS.Return.foundIn(fn)) {
         // If a return is inside body, transform `(params) { body }` to
         // `(params) { (() => { body })(); return value; }`.
         // TODO(jmesserly): we could instead generate the return differently,
         // and avoid the immediately invoked function.
         body = new JS.Call(new JS.ArrowFun([], fn.body), []).toStatement();
       }
       // Rewrite the function to include the return.
-      fn = new JS.Fun(fn.params, new JS.Block([body, returnValue]))
-        ..sourceInformation = fn.sourceInformation;
+      fn = new JS.Fun(fn.params, new JS.Block([body, returnValue]),
+          typeArgs: fn.typeArgs,
+          returnType: fn.returnType)..sourceInformation = fn.sourceInformation;
     }
 
     return annotate(
         new JS.Method(_elementMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
+        node,
         node.element);
   }
 
   /// Returns the name value of the `JSExportName` annotation (when compiling
   /// the SDK), or `null` if there's none. This is used to control the name
   /// under which functions are compiled and exported.
   String _getJSExportName(Element e) {
-    if (!currentLibrary.source.isInSystemLibrary) {
+    if (!e.source.isInSystemLibrary) {
       return null;
     }
     var jsName = findAnnotation(e, isJSExportNameAnnotation);
     return getConstantField(jsName, 'name', types.stringType)?.toStringValue();
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
@@ skipping 11 matching lines @@
     var name = node.name.name;
 
     var fn = _visit(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
 
     var id = new JS.Identifier(name);
-    body.add(annotate(new JS.FunctionDeclaration(id, fn), node.element));
+    body.add(annotate(new JS.FunctionDeclaration(id, fn), node, node.element));
     if (!_isDartRuntime) {
       body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
           .toStatement());
     }
 
     if (isPublic(name)) {
       _addExport(name, _getJSExportName(node.element) ?? name);
     }
     return _statement(body);
   }
@@ skipping 20 matching lines @@
   // Note: this allows silently passing args through to the body, which only
   // works if we don't do weird renamings of Dart params.
   JS.Fun _simplifyPassThroughArrowFunCallBody(JS.Fun fn) {
     if (fn.body is JS.Block && fn.body.statements.length == 1) {
       var stat = fn.body.statements.single;
       if (stat is JS.Return && stat.value is JS.Call) {
         JS.Call call = stat.value;
         if (call.target is JS.ArrowFun && call.arguments.isEmpty) {
           JS.ArrowFun innerFun = call.target;
           if (innerFun.params.isEmpty) {
-            return new JS.Fun(fn.params, innerFun.body);
+            return new JS.Fun(fn.params, innerFun.body,
+                typeArgs: fn.typeArgs, returnType: fn.returnType);
           }
         }
       }
     }
     return fn;
   }
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     return annotate(
         new JS.Method(_propertyName(name), _visit(node.functionExpression),
             isGetter: node.isGetter, isSetter: node.isSetter),
+        node,
         node.element);
   }
 
   bool _executesAtTopLevel(AstNode node) {
     var ancestor = node.getAncestor((n) =>
         n is FunctionBody ||
         (n is FieldDeclaration && n.staticKeyword == null) ||
         (n is ConstructorDeclaration && n.constKeyword == null));
     return ancestor == null;
   }
@@ skipping 32 matching lines @@
     throw 'Function has non function type: $type';
   }
 
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
 
     var parent = node.parent;
     var inStmt = parent.parent is FunctionDeclarationStatement;
+    var typeArgs = _emitTypeArgs(node.element).toList();
+    var returnType = emitTypeRef(node.element.returnType);
     if (parent is FunctionDeclaration) {
-      return _emitFunctionBody(params, node.body);
+      return _emitFunctionBody(params, node.body, typeArgs, returnType);
     } else {
       // Chrome Canary does not accept default values with destructuring in
       // arrow functions yet (e.g. `({a} = {}) => 1`) but happily accepts them
       // with regular functions (e.g. `function({a} = {}) { return 1 }`).
       // Note that Firefox accepts both syntaxes just fine.
       // TODO(ochafik): Simplify this code when Chrome Canary catches up.
       var canUseArrowFun = !node.parameters.parameters.any(_isNamedParam);
 
-      String code = canUseArrowFun ? '(#) => #' : 'function(#) { return # }';
       JS.Node jsBody;
       var body = node.body;
       if (body.isGenerator || body.isAsynchronous) {
-        jsBody = _emitGeneratorFunctionBody(params, body);
+        jsBody = _emitGeneratorFunctionBody(params, body, returnType);
       } else if (body is ExpressionFunctionBody) {
         jsBody = _visit(body.expression);
       } else {
-        code = canUseArrowFun ? '(#) => { #; }' : 'function(#) { #; }';
         jsBody = _visit(body);
       }
-      var clos = js.call(code, [params, jsBody]);
+      if (jsBody is JS.Expression && !canUseArrowFun) {
+        jsBody = js.statement("{ return #; }", [jsBody]);
+      }
+      var clos = canUseArrowFun
+          ? new JS.ArrowFun(params, jsBody,
+              typeArgs: typeArgs, returnType: returnType)
+          : new JS.Fun(params, jsBody,
+              typeArgs: typeArgs, returnType: returnType);
       if (!inStmt) {
         var type = getStaticType(node);
         return _emitFunctionTagged(clos, type,
             topLevel: _executesAtTopLevel(node));
       }
       return clos;
     }
   }
 
-  JS.Fun _emitFunctionBody(List<JS.Parameter> params, FunctionBody body) {
+  JS.Fun _emitFunctionBody(List<JS.Parameter> params, FunctionBody body,
+      List<JS.Identifier> typeArgs, JS.TypeRef returnType) {
     // sync*, async, async*
     if (body.isAsynchronous || body.isGenerator) {
       return new JS.Fun(
           params,
-          js.statement(
-              '{ return #; }', [_emitGeneratorFunctionBody(params, body)]));
+          js.statement('{ return #; }',
+              [_emitGeneratorFunctionBody(params, body, returnType)]),
+          returnType: returnType);
     }
     // normal function (sync)
-    return new JS.Fun(params, _visit(body));
+    return new JS.Fun(params, _visit(body),
+        typeArgs: typeArgs, returnType: returnType);
   }
 
   JS.Expression _emitGeneratorFunctionBody(
-      List<JS.Parameter> params, FunctionBody body) {
+      List<JS.Parameter> params, FunctionBody body, JS.TypeRef returnType) {
     var kind = body.isSynchronous ? 'sync' : 'async';
     if (body.isGenerator) kind += 'Star';
 
     // Transforms `sync*` `async` and `async*` function bodies
     // using ES6 generators.
     //
     // `sync*` wraps a generator in a Dart Iterable<T>:
     //
     // function name(<args>) {
     //   return dart.syncStar(function*(<args>) {
@@ skipping 23 matching lines @@
     // runtime/_generators.js has an example of what the code is generated as.
     var savedController = _asyncStarController;
     List jsParams;
     if (kind == 'asyncStar') {
       _asyncStarController = new JS.TemporaryId('stream');
       jsParams = [_asyncStarController]..addAll(params);
     } else {
       _asyncStarController = null;
       jsParams = params;
     }
-    JS.Expression gen = new JS.Fun(jsParams, _visit(body), isGenerator: true);
+    JS.Expression gen = new JS.Fun(jsParams, _visit(body),
+        isGenerator: true, returnType: returnType);
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
     _asyncStarController = savedController;
 
     var T = _emitTypeName(_getExpectedReturnType(body));
     return js.call('dart.#(#)', [
       kind,
       [gen, T]..addAll(params)
     ]);
   }
 
   @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 fn = _visit(func.functionExpression);
 
     var name = new JS.Identifier(func.name.name);
     JS.Statement declareFn;
     if (JS.This.foundIn(fn)) {
       declareFn = js.statement('const # = #.bind(this);', [name, fn]);
     } else {
       declareFn = new JS.FunctionDeclaration(name, fn);
     }
-    declareFn = annotate(declareFn, node.functionDeclaration.element);
+    declareFn = annotate(declareFn, node, node.functionDeclaration.element);
 
     return new JS.Block([
       declareFn,
       _emitFunctionTagged(name, func.element.type).toStatement()
     ]);
   }
 
+  @override
+  JS.Expression visitSimpleIdentifier(SimpleIdentifier node) =>
+      _emitSimpleIdentifier(node);
+
   /// 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) {
+  JS.Expression _emitSimpleIdentifier(SimpleIdentifier node,
+      {bool allowType: false}) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
@@ skipping 48 matching lines @@
     }
 
     if (element is TemporaryVariableElement) {
       if (name[0] == '#') {
         return new JS.InterpolatedExpression(name.substring(1));
       } else {
         return _getTemp(element, name);
       }
     }
 
-    return new JS.Identifier(name);
+    return annotate(
+        new JS.Identifier(name,
+            type: allowType ? emitTypeRef(node.bestType) : null),
+        node);
   }
 
   JS.TemporaryId _getTemp(Element key, String name) =>
       _temps.putIfAbsent(key, () => new JS.TemporaryId(name));
 
   List<Annotation> _parameterMetadata(FormalParameter p) =>
       (p is NormalFormalParameter)
           ? p.metadata
           : (p as DefaultFormalParameter).parameter.metadata;
 
@@ skipping 379 matching lines @@
   @override
   JS.Property visitNamedExpression(NamedExpression node) {
     assert(node.parent is ArgumentList);
     return new JS.Property(
         _propertyName(node.name.label.name), _visit(node.expression));
   }
 
   bool _isNamedParam(FormalParameter param) =>
       param.kind == ParameterKind.NAMED;
 
-  /// We cannot destructure named params that clash with JS reserved names:
-  /// see discussion in https://github.com/dart-lang/dev_compiler/issues/392.
-  bool _isDestructurableNamedParam(FormalParameter param) =>
-      _isNamedParam(param) &&
-      !invalidVariableName(param.identifier.name) &&
-      options.destructureNamedParams;
+  bool _canDestructureParams(FormalParameterList params) =>
+      canDestructureNamedParams(
+          params.parameters.where(_isNamedParam).map((p) => p.identifier.name),
+          options);
 
   @override
   List<JS.Parameter> visitFormalParameterList(FormalParameterList node) =>
       _emitFormalParameterList(node);
 
   List<JS.Parameter> _emitFormalParameterList(FormalParameterList node,
       {bool allowDestructuring: true}) {
     var result = <JS.Parameter>[];
 
     var namedVars = <JS.DestructuredVariable>[];
-    var destructure = allowDestructuring &&
-        node.parameters.where(_isNamedParam).every(_isDestructurableNamedParam);
+    var destructure = allowDestructuring && _canDestructureParams(node);
     var hasNamedArgsConflictingWithObjectProperties = false;
     var needsOpts = false;
 
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
         if (destructure) {
           if (_jsObjectProperties.contains(param.identifier.name)) {
             hasNamedArgsConflictingWithObjectProperties = true;
           }
           namedVars.add(new JS.DestructuredVariable(
-              name: _visit(param.identifier),
+              name: _emitSimpleIdentifier(param.identifier),
               defaultValue: _defaultParamValue(param)));
         } else {
           needsOpts = true;
         }
       } else {
         result.add(_visit(param));
       }
     }
 
     if (needsOpts) {
       result.add(_namedArgTemp);
     } else if (namedVars.isNotEmpty) {
       // Note: `var {valueOf} = {}` extracts `Object.prototype.valueOf`, so
       // in case there are conflicting names we create an object without
       // any prototype.
       var defaultOpts = hasNamedArgsConflictingWithObjectProperties
           ? js.call('Object.create(null)')
           : js.call('{}');
       result.add(new JS.DestructuredVariable(
           structure: new JS.ObjectBindingPattern(namedVars),
+          type: emitNamedParamsArgType(node.parameterElements),
           defaultValue: defaultOpts));
     }
     return result;
   }
 
   /// See ES6 spec (and `Object.getOwnPropertyNames(Object.prototype)`):
   /// http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-object-prototype-object
   /// http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-object.prototype-object
   static final Set<String> _jsObjectProperties = new Set<String>()
     ..addAll([
@@ skipping 111 matching lines @@
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.element is PropertyInducingElement) {
       // Static and instance fields are handled elsewhere.
       assert(node.element is TopLevelVariableElement);
       return _emitTopLevelField(node);
     }
 
-    var name = new JS.Identifier(node.name.name);
+    var name =
+        new JS.Identifier(node.name.name, type: emitTypeRef(node.element.type));
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
   bool _isFinalJSDecl(AstNode field) =>
       field is VariableDeclaration &&
       field.isFinal &&
       _isJSInvocation(field.initializer);
 
   /// Try to emit a constant static field.
   ///
@@ skipping 15 matching lines @@
 
     _loader.startCheckingReferences();
     JS.Expression jsInit = _visitInitializer(field);
     bool isLoaded = _loader.finishCheckingReferences();
 
     bool eagerInit =
         isLoaded && (field.isConst || _constField.isFieldInitConstant(field));
 
     var fieldName = field.name.name;
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
-      return annotateVariable(
+      return annotate(
           js.statement('#.# = #;', [
             classElem.name,
             _emitMemberName(fieldName, isStatic: true),
             jsInit
           ]),
+          field,
           field.element);
     }
 
     // This means it should be treated as a lazy field.
     // TODO(jmesserly): we're throwing away the initializer expression,
     // which will force us to regenerate it.
     return null;
   }
 
   /// Emits a top-level field.
@@ skipping 27 matching lines @@
       exportName = _getJSExportName(element) ?? fieldName;
     }
     if ((field.isConst && eagerInit && element is TopLevelVariableElement) ||
         isJSTopLevel) {
       // constant fields don't change, so we can generate them as `let`
       // but add them to the module's exports. However, make sure we generate
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName, exportName);
       var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
-      return annotateVariable(
-          js.statement(
-              '$declKeyword # = #;', [new JS.Identifier(fieldName), jsInit]),
-          field.element);
+      return js.statement('#;', [
+        annotate(
+            new JS.VariableDeclarationList(declKeyword, [
+              new JS.VariableInitialization(
+                  new JS.Identifier(fieldName,
+                      type: emitTypeRef(field.element.type)),
+                  jsInit)
+            ]),
+            field,
+            field.element)
+      ]);
     }
 
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
-      return annotateVariable(
-          js.statement('# = #;', [_visit(field.name), jsInit]), field.element);
+      return annotate(js.statement('# = #;', [_visit(field.name), jsInit]),
+          field, field.element);
     }
 
     return _emitLazyFields(currentLibrary, [field]);
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
     var value = _visit(node.initializer);
     // explicitly initialize to null, to avoid getting `undefined`.
     // TODO(jmesserly): do this only for vars that aren't definitely assigned.
     return value ?? new JS.LiteralNull();
   }
 
   JS.Statement _emitLazyFields(
       Element target, List<VariableDeclaration> fields) {
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       var element = node.element;
       var access = _emitMemberName(name, isStatic: true);
       methods.add(annotate(
           new JS.Method(
               access,
               js.call('function() { return #; }', _visit(node.initializer))
               as JS.Fun,
               isGetter: true),
+          node,
           _findAccessor(element, getter: true)));
 
       // TODO(jmesserly): currently uses a dummy setter to indicate writable.
       if (!node.isFinal && !node.isConst) {
         methods.add(annotate(
             new JS.Method(access, js.call('function(_) {}') as JS.Fun,
                 isSetter: true),
+            node,
             _findAccessor(element, getter: false)));
       }
     }
 
     JS.Expression objExpr;
     if (target is ClassElement) {
       objExpr = new JS.Identifier(target.type.name);
     } else {
       objExpr = _libraryName(target);
     }
@@ skipping 368 matching lines @@
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
       _visit(node.expression);
 
   @override
-  visitFormalParameter(FormalParameter node) {
-    var id = visitSimpleIdentifier(node.identifier);
+  visitFormalParameter(FormalParameter node) => _emitFormalParameter(node);
+
+  _emitFormalParameter(FormalParameter node, {bool allowType: true}) {
+    var id = _emitSimpleIdentifier(node.identifier, allowType: allowType);
 
     var isRestArg = findAnnotation(node.element, isJsRestAnnotation) != null;
     return isRestArg ? new JS.RestParameter(id) : id;
   }
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
@@ skipping 539 matching lines @@
 
   @override
   visitNode(AstNode node) {
     // TODO(jmesserly): verify this is unreachable.
     throw 'Unimplemented ${node.runtimeType}: $node';
   }
 
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
-    if (result is JS.Node) result.sourceInformation = node;
+    if (result is JS.Node) result = annotate(result, node);
     return result;
   }
 
   // TODO(jmesserly): this will need to be a generic method, if we ever want to
   // self-host strong mode.
   List /*<T>*/ _visitList /*<T>*/ (Iterable<AstNode> nodes) {
     if (nodes == null) return null;
     var result = /*<T>*/ [];
     for (var node in nodes) result.add(_visit(node));
     return result;
@@ skipping 122 matching lines @@
   JS.Identifier _libraryName(LibraryElement library) {
     if (library == currentLibrary) return _exportsVar;
     if (library.name == 'dart._runtime') return _runtimeLibVar;
     return _imports.putIfAbsent(
         library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   DartType getStaticType(Expression e) =>
       e.staticType ?? DynamicTypeImpl.instance;
 
-  @override
-  String getQualifiedName(TypeDefiningElement type) {
-    JS.TemporaryId id = _imports[type.library];
-    return id == null ? type.name : '${id.name}.${type.name}';
+  JS.Node annotate(JS.Node node, AstNode original, [Element element]) {
+    if (options.closure && element != null) {
+      node = node.withClosureAnnotation(
+          closureAnnotationFor(node, original, element, _namedArgTemp.name));
+    }
+    return node..sourceInformation = original;
   }
 
-  JS.Node annotate(JS.Node method, ExecutableElement e) =>
-      options.closure && e != null
-          ? method.withClosureAnnotation(
-              closureAnnotationFor(e, _namedArgTemp.name))
-          : method;
-
-  JS.Node annotateDefaultConstructor(JS.Node method, ClassElement e) =>
-      options.closure && e != null
-          ? method
-              .withClosureAnnotation(closureAnnotationForDefaultConstructor(e))
-          : method;
-
-  JS.Node annotateVariable(JS.Node node, VariableElement e) =>
-      options.closure && e != null
-          ? node.withClosureAnnotation(closureAnnotationForVariable(e))
-          : node;
-
-  JS.Node annotateTypeDef(JS.Node node, FunctionTypeAliasElement e) =>
-      options.closure && e != null
-          ? node.withClosureAnnotation(closureAnnotationForTypeDef(e))
-          : node;
-
   /// Returns true if this is any kind of object represented by `Number` in JS.
   ///
   /// In practice, this is 4 types: num, int, double, and JSNumber.
   ///
   /// JSNumber is the type that actually "implements" all numbers, hence it's
   /// a subtype of int and double (and num). It's in our "dart:_interceptors".
   bool _isNumberInJS(DartType t) => rules.isSubtypeOf(t, _types.numType);
 
   bool _isObjectGetter(String name) {
     PropertyAccessorElement element = _types.objectType.element.getGetter(name);
@@ skipping 125 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }