fix super from constructors

pkg/dev_compiler/lib/src/compiler/code_generator.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 HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 809 matching lines @@
     if (isGeneric) {
       if (isMixinAlias) {
         block.add(js.statement('const # = #;', [className, classExpr]));
       } else {
         block.add(new JS.ClassDeclaration(classExpr));
       }
     } else {
       block.add(js.statement('# = #;', [className, classExpr]));
     }
 
-    if (!isMixinAlias) _defineConstructors(classElem, className, [], block, []);
+    if (!isMixinAlias) {
+      block.addAll(_defineConstructors(classElem, className, [], []));
+    }
 
     if (classElem.interfaces.isNotEmpty) {
       block.add(js.statement('#[#.implements] = () => #;', [
         className,
         _runtimeModule,
         new JS.ArrayInitializer(classElem.interfaces.map(_emitType).toList())
       ]));
     }
 
     if (isGeneric) {
@@ skipping 48 matching lines @@
       // type parameter. So we can use their local variable name directly.
       className = new JS.Identifier(classElem.name);
     } else {
       className = _emitTopLevelName(classElem);
     }
 
     var savedClassProperties = _classProperties;
     _classProperties =
         new ClassPropertyModel.build(_extensionTypes, virtualFields, classElem);
 
+    var jsCtors = _defineConstructors(classElem, className, fields, ctors);
     var classExpr = _emitClassExpression(classElem, _emitClassMethods(node),
         fields: allFields);
 
     var body = <JS.Statement>[];
     _initExtensionSymbols(classElem, methods, fields, body);
     _emitSuperHelperSymbols(_superHelperSymbols, body);
 
     // Emit the class, e.g. `core.Object = class Object { ... }`
     _defineClass(classElem, className, classExpr, body);
-    _defineConstructors(classElem, className, fields, body, ctors);
+    body.addAll(jsCtors);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerNames = _getJSPeerNames(classElem);
     JS.Statement deferredBaseClass =
         _setBaseClass(classElem, className, jsPeerNames, body);
 
     _emitClassTypeTests(classElem, className, body);
 
     _emitVirtualFieldSymbols(classElem, body);
     _emitClassSignature(methods, allFields, classElem, ctors, className, body);
@@ skipping 789 matching lines @@
       }
       var deferredBaseClass = _callHelperStatement(
           'setBaseClass(#, #);', [className, newBaseClass]);
       if (typeFormals.isNotEmpty) return deferredBaseClass;
       body.add(deferredBaseClass);
     }
     return null;
   }
 
   /// Defines all constructors for this class as ES5 constructors.
-  void _defineConstructors(
+  List<JS.Statement> _defineConstructors(
       ClassElement classElem,
       JS.Expression className,
       List<FieldDeclaration> fields,
-      List<JS.Statement> body,
       List<ConstructorDeclaration> ctors) {
     // See if we have a "call" with a statically known function type:
     //
     // - if it's a method, then it does because all methods do,
     // - if it's a getter, check the return type.
     //
     // Other cases like a getter returning dynamic/Object/Function will be
     // handled at runtime by the dynamic call mechanism. So we only
     // concern ourselves with statically known function types.
     //
     // For the same reason, we can ignore "noSuchMethod".
     // call-implemented-by-nSM will be dispatched by dcall at runtime.
     bool isCallable = classElem.lookUpMethod('call', null) != null ||
         classElem.lookUpGetter('call', null)?.returnType is FunctionType;
 
+    var body = <JS.Statement>[];
     void addConstructor(ConstructorElement element, JS.Expression jsCtor) {
       var ctorName = _constructorName(element);
       if (JS.invalidStaticFieldName(element.name)) {
         jsCtor =
             _callHelper('defineValue(#, #, #)', [className, ctorName, jsCtor]);
       } else {
         jsCtor = js.call('#.# = #', [className, ctorName, jsCtor]);
       }
       body.add(js.statement('#.prototype = #.prototype;', [jsCtor, className]));
     }
 
     if (classElem.isMixinApplication) {
       var supertype = classElem.supertype;
       for (var ctor in classElem.constructors) {
         List<JS.Identifier> jsParams = _emitParametersForElement(ctor);
         var superCtor = supertype.lookUpConstructor(ctor.name, ctor.library);
         var superCall =
             _superConstructorCall(classElem, className, superCtor, jsParams);
         addConstructor(
             ctor,
             _finishConstructorFunction(
                 jsParams,
                 new JS.Block(superCall != null ? [superCall] : []),
                 isCallable));
       }
-      return;
+      return body;
     }
 
     // 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) {
       var superCall = _superConstructorCall(classElem, className);
-      List<JS.Statement> body = [_initializeFields(fields)];
-      if (superCall != null) body.add(superCall);
+      var ctorBody = <JS.Statement>[_initializeFields(fields)];
+      if (superCall != null) ctorBody.add(superCall);
 
       addConstructor(classElem.unnamedConstructor,
-          _finishConstructorFunction([], new JS.Block(body), isCallable));
-      return;
+          _finishConstructorFunction([], new JS.Block(ctorBody), isCallable));
+      return body;
     }
 
     bool foundConstructor = false;
     for (var ctor in ctors) {
       var element = ctor.element;
       if (element.isFactory || _externalOrNative(ctor)) continue;
 
       addConstructor(
           element, _emitConstructor(ctor, fields, isCallable, className));
       foundConstructor = true;
     }
 
     // If classElement has only factory constructors, and it can be mixed in,
     // then we need to emit a special hidden default constructor for use by
     // mixins.
     if (!foundConstructor && classElem.supertype.isObject) {
       body.add(
           js.statement('(#[#] = function() { # }).prototype = #.prototype;', [
         className,
         _callHelper('mixinNew'),
         [_initializeFields(fields)],
         className
       ]));
     }
+
+    return body;
   }
 
   /// Emits static fields for a class, and initialize them eagerly if possible,
   /// otherwise define them as lazy properties.
   void _emitStaticFields(List<FieldDeclaration> staticFields,
       ClassElement classElem, List<JS.Statement> body) {
     var lazyStatics = staticFields.expand((f) => f.fields.variables).toList();
     if (lazyStatics.isNotEmpty) {
       body.add(_emitLazyFields(classElem, lazyStatics));
     }
@@ skipping 4116 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }