a few small refactorings to closure workarounds

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.
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
@@ skipping 359 matching lines @@
     var supertype = element.supertype;
     if (!supertype.isObject) {
       for (var ctor in element.constructors) {
         var parentCtor = supertype.lookUpConstructor(ctor.name, ctor.library);
         var fun = js.call('function() { super.#(...arguments); }',
             [_constructorName(parentCtor)]) as JS.Fun;
         body.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
-    var classExpr = new JS.ClassExpression(
-        new JS.Identifier(element.name), _classHeritage(element), body);
-
-    return _finishClassDef(
-        element.type, _emitClassHeritageWorkaround(classExpr));
+    var cls = _emitClassDeclaration(element, body);
+    return _finishClassDef(element.type, cls);
   }
 
   JS.Statement _emitJsType(String dartClassName, DartObject jsName) {
     var jsTypeName =
         getConstantField(jsName, 'name', types.stringType)?.toStringValue();
 
     if (jsTypeName != null && jsTypeName != dartClassName) {
       // We export the JS type as if it was a Dart type. For example this allows
       // `dom.InputElement` to actually be HTMLInputElement.
       // TODO(jmesserly): if we had the JS name on the Element, we could just
@@ skipping 19 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),
-        typeParams: _emitTypeFormals(classElem.typeParameters),
-        fields:
-            _emitFieldDeclarations(classElem, fields, staticFields).toList());
+    var allFields = new List.from(fields)..addAll(staticFields);
+
+    var classDecl = _emitClassDeclaration(
+        classElem, _emitClassMethods(node, ctors, fields),
+        fields: allFields);
 
     String jsPeerName;
     var jsPeer = findAnnotation(classElem, isJsPeerInterface);
     // Only look at "Native" annotations on registered extension types.
     // E.g., we're current ignoring the ones in dart:html.
     if (jsPeer == null && _extensionTypes.contains(classElem)) {
       jsPeer = findAnnotation(classElem, isNativeAnnotation);
     }
     if (jsPeer != null) {
       jsPeerName =
           getConstantField(jsPeer, 'name', types.stringType)?.toStringValue();
       if (jsPeerName.contains(',')) {
         jsPeerName = jsPeerName.split(',')[0];
       }
     }
 
-    var body = _finishClassMembers(classElem, classExpr, ctors, fields,
+    var body = _finishClassMembers(classElem, classDecl, ctors, fields,
         staticFields, methods, node.metadata, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
     if (jsPeerName != null) {
       // This class isn't allowed to be lazy, because we need to set up
       // the native JS type eagerly at this point.
       // If we wanted to support laziness, we could defer the hookup until
       // the end of the Dart library cycle load.
       assert(_loader.isLoaded(classElem));
 
       // TODO(jmesserly): this copies the dynamic members.
       // Probably fine for objects coming from JS, but not if we actually
       // 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;
   }
 
   List<JS.Identifier> _emitTypeFormals(List<TypeParameterElement> typeFormals) {
-    if (!options.closure) return null;
     return typeFormals
         .map((t) => new JS.Identifier(t.name))
         .toList(growable: false);
   }
 
-  /// Emit field declarations for TypeScript & Closure's ES6_TYPED
+  /// Emits a field declaration 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());
-    }
+  JS.VariableDeclarationList _emitTypeScriptField(FieldDeclaration field) {
+    return new JS.VariableDeclarationList(
+        field.isStatic ? 'static' : null,
+        field.fields.variables
+            .map((decl) => new JS.VariableInitialization(
+                new JS.Identifier(
+                    // TODO(ochafik): use a refactored _emitMemberName instead.
+                    decl.name.name,
+                    type: emitTypeRef(decl.element.type)),
+                null))
+            .toList(growable: false));
   }
 
   @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.
@@ skipping 10 matching lines @@
     for (var i = 0; i < fields.length; ++i) {
       properties.add(new JS.Property(
           js.number(i), js.string('${type.name}.${fields[i].name}')));
     }
     var nameMap = new JS.ObjectInitializer(properties, multiline: true);
     var toStringF = new JS.Method(js.string('toString'),
         js.call('function() { return #[this.index]; }', nameMap) as JS.Fun);
 
     // Create enum class
     var classExpr = new JS.ClassExpression(
-        id, _classHeritage(element), [constructor, toStringF]);
+        id, _emitClassHeritage(element), [constructor, toStringF]);
     var result = <JS.Statement>[js.statement('#', classExpr)];
 
     // Create static fields for each enum value
     for (var i = 0; i < fields.length; ++i) {
       result.add(js.statement('#.# = dart.const(new #(#));',
           [id, fields[i].name, id, js.number(i)]));
     }
 
     // Create static values list
     var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
@@ skipping 60 matching lines @@
         var typeElement = typeArg.element;
         // FIXME(vsm): This does not track mutual recursive dependences.
         if (current == typeElement || _deferIfNeeded(typeArg, current)) {
           return true;
         }
       }
     }
     return false;
   }
 
-  JS.Expression _classHeritage(ClassElement element) {
+  JS.Statement _emitClassDeclaration(
+      ClassElement element, List<JS.Method> methods,
+      {List<FieldDeclaration> fields}) {
+    String name = element.name;
+    var heritage = _emitClassHeritage(element);
+    var typeParams = _emitTypeFormals(element.typeParameters);
+    var jsFields = fields?.map(_emitTypeScriptField)?.toList();
+
+    // Workaround for Closure: super classes must be qualified paths.
+    // TODO(jmesserly): is there a bug filed? we need to get out of the business
+    // of working around bugs in other transpilers...
+    JS.Statement workaroundSuper = null;
+    if (options.closure && heritage is JS.Call) {
+      var superVar = new JS.TemporaryId('$name\$super');
+      workaroundSuper = js.statement('const # = #;', [superVar, heritage]);
+      heritage = superVar;
+    }
+    var decl = new JS.ClassDeclaration(new JS.ClassExpression(
+        new JS.Identifier(name), heritage, methods,
+        typeParams: typeParams, fields: jsFields));
+    if (workaroundSuper != null) {
+      return new JS.Block([workaroundSuper, decl]);
+    }
+    return decl;
+  }
+
+  JS.Expression _emitClassHeritage(ClassElement element) {
     var type = element.type;
     if (type.isObject) return null;
 
     // Assume we can load eagerly, until proven otherwise.
     _loader.startTopLevel(element);
 
     // Find the super type
     JS.Expression heritage;
     var supertype = type.superclass;
     if (_deferIfNeeded(supertype, element)) {
@@ skipping 129 matching lines @@
   JS.Expression _instantiateAnnotation(Annotation node) {
     var element = node.element;
     if (element is ConstructorElement) {
       return _emitInstanceCreationExpression(element, element.returnType,
           node.constructorName, node.arguments, true);
     } else {
       return _visit(node.name);
     }
   }
 
-  _isQualifiedPath(JS.Expression node) =>
-      node is JS.Identifier ||
-      node is JS.PropertyAccess &&
-          _isQualifiedPath(node.receiver) &&
-          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,
-            typeParams: cls.typeParams, fields: 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,
-      JS.ClassExpression cls,
+      JS.Statement classDecl,
       List<ConstructorDeclaration> ctors,
       List<FieldDeclaration> fields,
       List<FieldDeclaration> staticFields,
       List<MethodDeclaration> methods,
       List<Annotation> metadata,
       String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
 
     if (_extensionTypes.contains(classElem)) {
@@ skipping 12 matching lines @@
             }
           }
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
 
-    body.add(_emitClassHeritageWorkaround(cls));
+    body.add(classDecl);
 
     // TODO(jmesserly): we should really just extend native Array.
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
       body.add(js.statement('dart.setBaseClass(#, dart.global.#);',
           [classElem.name, _propertyName(jsPeerName)]));
     }
 
     // Deferred Superclass
     if (_hasDeferredSupertype.contains(classElem)) {
       body.add(js.statement('#.prototype.__proto__ = #.prototype;',
@@ skipping 2660 matching lines @@
 
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
     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) {
+  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;
   }
 
   /// 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;
     return new JS.Expression.binary(
@@ skipping 300 matching lines @@
     var rules = new StrongTypeSystemImpl();
     var codegen =
         new JSCodegenVisitor(compiler, rules, library, _extensionTypes, fields);
     var module = codegen.emitLibrary(unit);
     var out = compiler.getOutputPath(library.source.uri);
     var flags = compiler.options;
     var serverUri = flags.serverMode
         ? Uri.parse('http://${flags.host}:${flags.port}/')
         : null;
     return writeJsLibrary(module, out, compiler.inputBaseDir, serverUri,
+        emitTypes: options.closure,
         emitSourceMaps: options.emitSourceMaps,
         fileSystem: compiler.fileSystem);
   }
 }
 
 /// 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);
 
@@ skipping 10 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);
 }