Avoid crash for type variables in mixed in fields.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 917 matching lines @@
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(
       ResolvedAst constructorResolvedAst,
       List<HInstruction> compiledArguments,
       List<ResolvedAst> constructorResolvedAsts,
-      Map<Element, HInstruction> fieldValues,
+      Map<FieldElement, HInstruction> fieldValues,
       FunctionElement caller) {
     ConstructorElement callee = constructorResolvedAst.element.implementation;
+
     reporter.withCurrentElement(callee, () {
+      Set<ClassElement> includedClasses = new Set<ClassElement>();
       constructorResolvedAsts.add(constructorResolvedAst);
-      ClassElement enclosingClass = callee.enclosingClass;
-      if (rtiNeed.classNeedsRti(enclosingClass)) {
-        // If [enclosingClass] needs RTI, we have to give a value to its
-        // type parameters.
-        ClassElement currentClass = caller.enclosingClass;
-        // For a super constructor call, the type is the supertype of
-        // [currentClass]. For a redirecting constructor, the type is
-        // the current type. [InterfaceType.asInstanceOf] takes care
-        // of both.
-        ResolutionInterfaceType type =
-            currentClass.thisType.asInstanceOf(enclosingClass);
-        type = localsHandler.substInContext(type);
-        List<ResolutionDartType> arguments = type.typeArguments;
-        List<ResolutionDartType> typeVariables = enclosingClass.typeVariables;
-        if (!type.isRaw) {
-          assert(arguments.length == typeVariables.length);
-          Iterator<ResolutionDartType> variables = typeVariables.iterator;
-          type.typeArguments.forEach((ResolutionDartType argument) {
-            variables.moveNext();
-            ResolutionTypeVariableType typeVariable = variables.current;
-            localsHandler.updateLocal(
-                localsHandler.getTypeVariableAsLocal(typeVariable),
-                typeBuilder.analyzeTypeArgument(argument, sourceElement));
-          });
-        } else {
-          // If the supertype is a raw type, we need to set to null the
-          // type variables.
-          for (ResolutionTypeVariableType variable in typeVariables) {
-            localsHandler.updateLocal(
-                localsHandler.getTypeVariableAsLocal(variable),
-                graph.addConstantNull(closedWorld));
+      ClassElement currentClass = caller.enclosingClass;
+
+      /// Include locals for type variable used in [member].
+      void includeTypeVariables(MemberElement member) {
+        ClassElement enclosingClass = member.enclosingClass;
+        if (!includedClasses.add(enclosingClass)) return;
+
+        if (rtiNeed.classNeedsRti(enclosingClass)) {
+          // If [enclosingClass] needs RTI, we have to give a value to its
+          // type parameters.
+          // For a super constructor call, the type is the supertype of
+          // [currentClass]. For a redirecting constructor, the type is
+          // the current type. [InterfaceType.asInstanceOf] takes care
+          // of both.
+          ResolutionInterfaceType type =
+              currentClass.thisType.asInstanceOf(enclosingClass);
+          type = localsHandler.substInContext(type);
+          List<ResolutionDartType> arguments = type.typeArguments;
+          List<ResolutionDartType> typeVariables = enclosingClass.typeVariables;
+          if (!type.isRaw) {
+            assert(arguments.length == typeVariables.length);
+            Iterator<ResolutionDartType> variables = typeVariables.iterator;
+            type.typeArguments.forEach((ResolutionDartType argument) {
+              variables.moveNext();
+              ResolutionTypeVariableType typeVariable = variables.current;
+              localsHandler.updateLocal(
+                  localsHandler.getTypeVariableAsLocal(typeVariable),
+                  typeBuilder.analyzeTypeArgument(argument, sourceElement));
+            });
+          } else {
+            // If the supertype is a raw type, we need to set to null the
+            // type variables.
+            for (ResolutionTypeVariableType variable in typeVariables) {
+              localsHandler.updateLocal(
+                  localsHandler.getTypeVariableAsLocal(variable),
+                  graph.addConstantNull(closedWorld));
+            }
           }
         }
       }
 
+      includeTypeVariables(callee);
+
       // For redirecting constructors, the fields will be initialized later
       // by the effective target.
       if (!callee.isRedirectingGenerative) {
+        callee.enclosingClass.implementation.forEachInstanceField(
+            (ClassElement enclosingClass, FieldElement member) {
+          includeTypeVariables(member);

[Siggi Cherem (dart-lang), 2017/08/17 18:44:50]

any reason why this shouldn't be done in buildFieldInitializers?

[Johnni Winther, 2017/08/18 14:09:34]

[inlinedFrom] accesses the missing values before the call to
[buildFieldInitializers]

+        });
         inlinedFrom(constructorResolvedAst, () {
           buildFieldInitializers(
               callee.enclosingClass.implementation, fieldValues);
         });
       }
 
       int index = 0;
       FunctionSignature params = callee.functionSignature;
       params.orderedForEachParameter((_parameter) {
         ParameterElement parameter = _parameter;
@@ skipping 26 matching lines @@
       buildInitializers(callee, constructorResolvedAsts, fieldValues);
       localsHandler.scopeInfo = oldScopeInfo;
       resolvedAst = oldResolvedAst;
       elementInferenceResults = oldElementInferenceResults;
     });
   }
 
   void buildInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
-      Map<Element, HInstruction> fieldValues) {
+      Map<FieldElement, HInstruction> fieldValues) {
     assert(
         resolvedAst.element == constructor.declaration,
         failedAt(constructor,
             "Expected ResolvedAst for $constructor, found $resolvedAst"));
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       buildParsedInitializers(
           constructor, constructorResolvedAsts, fieldValues);
     } else {
       buildSynthesizedConstructorInitializers(
           constructor, constructorResolvedAsts, fieldValues);
     }
   }
 
   void buildSynthesizedConstructorInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
-      Map<Element, HInstruction> fieldValues) {
+      Map<FieldElement, HInstruction> fieldValues) {
     assert(
         constructor.isSynthesized,
         failedAt(
             constructor, "Unexpected unsynthesized constructor: $constructor"));
     List<HInstruction> arguments = <HInstruction>[];
     HInstruction compileArgument(ParameterElement parameter) {
       return localsHandler.readLocal(parameter);
     }
 
     ConstructorElement target = constructor.definingConstructor.implementation;
@@ skipping 25 matching lines @@
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    *
    * Invariant: The [constructor] and elements in [constructors] must all be
    * implementation elements.
    */
   void buildParsedInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
-      Map<Element, HInstruction> fieldValues) {
+      Map<FieldElement, HInstruction> fieldValues) {
     assert(
         resolvedAst.element == constructor.declaration, failedAt(constructor));
     assert(constructor.isImplementation, failedAt(constructor));
     assert(
         !constructor.isSynthesized,
         failedAt(
             constructor, "Unexpected synthesized constructor: $constructor"));
     ast.FunctionExpression functionNode = resolvedAst.node;
 
     bool foundSuperOrRedirect = false;
@@ skipping 119 matching lines @@
 
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     if (inliningStack.isEmpty) {
       // The initializer list could contain closures.
       openFunction(functionElement, function);
     }
 
-    Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
+    Map<FieldElement, HInstruction> fieldValues =
+        new Map<FieldElement, HInstruction>();
 
     // Compile the possible initialization code for local fields and
     // super fields, unless this is a redirecting constructor, in which case
     // the effective target will initialize these.
     if (!functionElement.isRedirectingGenerative) {
       buildFieldInitializers(classElement, fieldValues);
     }
 
     // Compile field-parameters such as [:this.x:].
     FunctionSignature params = functionElement.functionSignature;
@@ skipping 5599 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }