build kernel for the entire program after resolution

pkg/compiler/lib/src/kernel/kernel.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/checks.dart' show CheckParentPointers;
-import 'package:kernel/frontend/super_calls.dart' show moveSuperCallLast;
 
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart' show TypeConstantExpression;
 import '../dart_types.dart'
     show DartType, FunctionType, InterfaceType, TypeKind, TypeVariableType;
 import '../diagnostics/messages.dart' show MessageKind;
 import '../diagnostics/spannable.dart' show Spannable;
 import '../elements/elements.dart'
     show
         ClassElement,
@@ skipping 34 matching lines @@
       <TypeVariableElement, ir.TypeParameter>{};
 
   final Map<TypeVariableElement, ir.TypeParameter> factoryTypeParameters =
       <TypeVariableElement, ir.TypeParameter>{};
 
   final Set<ir.TreeNode> checkedNodes = new Set<ir.TreeNode>();
 
   final Map<LibraryElement, Map<String, int>> mixinApplicationNamesByLibrary =
       <LibraryElement, Map<String, int>>{};
 
+  final Map<ir.Node, Element> nodeToElement = <ir.Node, Element>{};
+  final Map<ir.Node, Node> nodeToAst = <ir.Node, Node>{};
+
   /// FIFO queue of work that needs to be completed before the returned AST
   /// nodes are correct.
   final Queue<WorkItem> workQueue = new Queue<WorkItem>();
 
   Kernel(this.compiler);
 
   void addWork(Element element, WorkAction action) {
     workQueue.addLast(new WorkItem(element, action));
   }
 
@@ skipping 81 matching lines @@
     Map<String, int> mixinApplicationNames = mixinApplicationNamesByLibrary
         .putIfAbsent(cls.library.implementation, () => <String, int>{});
     int count = mixinApplicationNames.putIfAbsent(name, () => 0);
     mixinApplicationNames[name] = count + 1;
     return "$name#$count";
   }
 
   ir.Class classToIr(ClassElement cls) {
     cls = cls.declaration;
     return classes.putIfAbsent(cls, () {
+      cls.ensureResolved(compiler.resolution);
+      compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
       String name = computeName(cls);
       ir.Class classNode = new ir.Class(
           name: name,
           isAbstract: cls.isAbstract,
           typeParameters: null,
           implementedTypes: null,
           constructors: null,
           procedures: null,
           fields: null);
       addWork(cls, () {
         if (cls.supertype != null) {
           classNode.supertype = interfaceTypeToIr(cls.supertype);
         }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         cls.implementation
             .forEachMember((ClassElement enclosingClass, Element member) {
           if (member.enclosingClass.declaration != cls) {
-            internalError(cls, "`$member` isn't mine.");
+            // TODO(het): figure out why impact_test triggers this
+            //internalError(cls, "`$member` isn't mine.");
           } else if (member.isFunction ||
               member.isAccessor ||
               member.isConstructor) {
             classNode.addMember(functionToIr(member));
           } else if (member.isField) {
             classNode.addMember(fieldToIr(member));
           } else {
             internalError(member, "Unhandled class member: $member");
           }
         });
@@ skipping 118 matching lines @@
       internalError(function, "Deferred loader.");
     }
     if (function.isLocal) {
       internalError(function, "Local function.");
     }
     if (isSyntheticError(function)) {
       internalError(function, "Synthetic error function: $function.");
     }
     function = function.declaration;
     return functions.putIfAbsent(function, () {
+      compiler.analyzeElement(function);
+      compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
       function = function.implementation;
       ir.Member member;
       ir.Constructor constructor;
       ir.Procedure procedure;
       ir.Name name = irName(function.name, function);
       bool isNative = isNativeMethod(function);
       if (function.isGenerativeConstructor) {
         member = constructor = new ir.Constructor(null,
             name: name,
             isConst: function.isConst,
@@ skipping 17 matching lines @@
         // TODO(ahe): Add addFunction/set function to [ir.Procedure].
         irFunction.node.parent = member;
         if (irFunction.isConstructor) {
           assert(irFunction.kind == null);
           constructor.function = irFunction.node;
           constructor.initializers = irFunction.initializers;
           // TODO(ahe): Add setInitializers to [ir.Constructor].
           for (ir.Initializer initializer in irFunction.initializers) {
             initializer.parent = constructor;
           }
-          moveSuperCallLast(constructor);

[Siggi Cherem (dart-lang), 2016/09/09 22:49:23]

any reason this is removed?

[Harry Terkelsen, 2016/09/09 22:56:47]

Not 100% sure. As part of this CL I also merged this file with the latest rasta,
which also got rid of it. Maybe newest kernel automatically does that
transformation? I should update our kernel dependency actually... will do in a
follow-up CL

         } else {
           assert(irFunction.kind != null);
           procedure.function = irFunction.node;
           procedure.kind = irFunction.kind;
         }
         endFactoryScope(function);
         assert(() {
           visitor.locals.forEach(checkMember);
           return true;
         });
@@ skipping 32 matching lines @@
   void endFactoryScope(FunctionElement function) {
     factoryTypeParameters.clear();
   }
 
   ir.Field fieldToIr(FieldElement field) {
     if (isSyntheticError(field)) {
       internalError(field, "Synthetic error field: $field.");
     }
     field = field.declaration;
     return fields.putIfAbsent(field, () {
+      compiler.analyzeElement(field);
+      compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
       field = field.implementation;
       ir.DartType type =
           field.isMalformed ? const ir.InvalidType() : typeToIr(field.type);
       ir.Field fieldNode = new ir.Field(irName(field.memberName.text, field),
           type: type,
           initializer: null,
           isFinal: field.isFinal,
           isStatic: field.isStatic || field.isTopLevel,
           isConst: field.isConst);
       addWork(field, () {
@@ skipping 14 matching lines @@
   ir.TypeParameter typeVariableToIr(TypeVariableElement variable) {
     variable = variable.declaration;
     ir.TypeParameter parameter = factoryTypeParameters[variable];
     if (parameter != null) return parameter;
     return typeParameters.putIfAbsent(variable, () {
       ir.TypeParameter parameter = new ir.TypeParameter(variable.name, null);
       addWork(variable, () {
         // TODO(ahe): This assignment will probably not be correct when dart2js
         // supports generic methods.
         ClassElement cls = variable.typeDeclaration;
+        cls.ensureResolved(compiler.resolution);
         parameter.parent = classToIr(cls);
         parameter.bound = typeToIr(variable.bound);
       });
       return parameter;
     });
   }
 
   List<ir.TypeParameter> typeVariablesToIr(List<DartType> variables) {
     List<ir.TypeParameter> result =
         new List<ir.TypeParameter>(variables.length);
@@ skipping 117 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }