dart2js cps: Change how type variables are accessed in constructors.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 93 matching lines @@
       if (variable != other.index2variable[i]) return false;
 
       // The variable maps to the same index in both environments.
       int index = variable2index[variable];
       if (index == null || index != other.variable2index[variable]) {
         return false;
       }
     }
     return true;
   }
+
+  bool contains(Local local) => variable2index.containsKey(local);
 }
 
 /// The abstract base class of objects that emit jumps to a continuation and
 /// give a handle to the continuation and its environment.
 abstract class JumpCollector {
   final JumpTarget target;
 
   ir.Continuation _continuation = null;
   final Environment _continuationEnvironment;
 
@@ skipping 2503 matching lines @@
     }
   }
 
   /// Obtains the internal type representation of the type held in [variable].
   ///
   /// The value of [variable] is taken from the current receiver object, or
   /// if we are currently building a constructor field initializer, from the
   /// corresponding type argument (field initializers are evaluated before the
   /// receiver object is created).
   ir.Primitive buildTypeVariableAccess(TypeVariableType variable) {
-    ir.Parameter accessTypeArgumentParameter() {
-      for (int i = 0; i < environment.length; i++) {
-        Local local = environment.index2variable[i];
-        if (local is TypeInformationParameter &&
-            local.variable == variable.element) {
-          return environment.index2value[i];
-        }
-      }
-      throw 'unable to find constructor parameter for type variable $variable.';
+    // If the local exists in the environment, use that.
+    // This is put here when we are inside a constructor or field initializer,
+    // (or possibly a closure inside one of these).
+    Local local = new TypeVariableLocal(variable, state.currentElement);
+    if (environment.contains(local)) {
+      return environment.lookup(local);
     }
 
-    if (jsState.inInitializers) {
-      return accessTypeArgumentParameter();
-    } else {
-      ir.Primitive target = buildThis();
-      return addPrimitive(new ir.ReadTypeVariable(variable, target));
-    }
+    // If the type variable is not in a local, access it one the receiver.

[karlklose, 2015/05/28 08:12:19]

'access it one the receiver' -> 'read the value from the receiver object'?

[asgerf, 2015/05/28 09:34:21]

Done.

+    ir.Primitive target = buildThis();
+    return addPrimitive(new ir.ReadTypeVariable(variable, target));
+  }
+
+  /// Make the given type variable accessible through the local environment
+  /// with the value of [binding].
+  void declareTypeVariable(TypeVariableType variable, DartType binding) {
+    environment.extend(
+        new TypeVariableLocal(variable, state.currentElement),
+        buildTypeExpression(binding));
   }
 
   @override
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable) {
     ir.Primitive typeArgument = buildTypeVariableAccess(variable);
     return addPrimitive(new ir.ReifyRuntimeType(typeArgument));
   }
 
   ir.Primitive buildInvocationMirror(Selector selector,
                                      List<ir.Primitive> arguments) {
@@ skipping 93 matching lines @@
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }
-
-/// Synthetic parameter to a JavaScript factory method that takes the type
-/// argument given for the type variable [variable].
-class TypeInformationParameter implements Local {
-  final TypeVariableElement variable;
-  final ExecutableElement executableContext;
-  TypeInformationParameter(this.variable, this.executableContext);
-  String get name => variable.name;
-}