Create local alias for super class in --closure mode (issue #312)

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 dev_compiler.src.codegen.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;
@@ skipping 357 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 classDecl = new JS.ClassDeclaration(new JS.ClassExpression(
-        new JS.Identifier(element.name), _classHeritage(element), body));
+    var classExpr = new JS.ClassExpression(
+        new JS.Identifier(element.name), _classHeritage(element), body);
 
-    return _finishClassDef(element.type, classDecl);
+    return _finishClassDef(element.type, _emitClassDeclaration(classExpr));

[Jennifer Messerly, 2016/02/01 23:59:55]

The same fix is likely needed for ClassTypeAlias

[ochafik, 2016/02/03 19:41:33]

Done.

   }
 
   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 270 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;
+
+  JS.Statement _emitClassDeclaration(JS.ClassExpression cls) {

[Jennifer Messerly, 2016/02/01 23:59:55]

from the naming convention, I would probably expect that this emits a Dart
ClassDeclaration.

Maybe _emitClassHeritageWorkaround

[ochafik, 2016/02/03 19:41:33]

Done.

+    var body = <JS.Statement>[];

[Jennifer Messerly, 2016/02/01 23:59:55]

this can go inside the if:

if (...) {
  return new JS.Block(<JS.Statement>[
    js.statement('const # = #;', [superVar, cls.heritage]),
    new JS.ClassExpression(cls.name, superVar, cls.methods)
  ]);
}
return new JS.ClassDeclaration(cls);

that way we aren't building up a List just to immediately throw it away for the
normal code path.

[ochafik, 2016/02/03 19:41:33]

Done.

+    if (options.closure &&
+        cls.heritage != null && !_isQualifiedPath(cls.heritage)) {
+      // Workaround for Closure: super classes must be qualified paths.

[Jennifer Messerly, 2016/02/01 23:59:55]

After the method rename, this would be good as a doc comment.

[ochafik, 2016/02/03 19:41:33]

Done.

+      var superVar = new JS.Identifier(cls.name.name + r'$super');

[Jennifer Messerly, 2016/02/01 23:59:55]

This should be a temp. Use `new JS.TemporaryId`. That will let the compiler know
that it is safe to rename, in case it conflicts with any user-controlled names
in the Dart scope. JS.TemporaryId's use pointer identity to know whether it is a
use of the same variable.

[ochafik, 2016/02/03 19:41:33]

Done.

+      body.add(js.statement('const # = #;', [superVar, cls.heritage]));
+      cls = new JS.ClassExpression(cls.name, superVar, cls.methods);
+    }
+    body.add(new JS.ClassDeclaration(cls));
+    return _statement(body);
+  }
+
   /// 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,
       List<ConstructorDeclaration> ctors,
       List<FieldDeclaration> fields,
       List<MethodDeclaration> methods,
       List<Annotation> metadata,
       String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
 
     if (_extensionTypes.contains(classElem)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
 
-    body.add(new JS.ClassDeclaration(cls));
+    body.add(_emitClassDeclaration(cls));
 
     // 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 2882 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);
 }