dart2js cps: Handle error cases.

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 439 matching lines @@
 
   /// Called before building the update of a for-loop.
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables);
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
   void _createFunctionParameter(Local parameterElement);
   void _createThisParameter();
 
+  /// Reifies the value of [variable] on the current receiver object.
+  ir.Primitive buildReifyTypeVariable(TypeVariableType variable);
+
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
@@ skipping 1781 matching lines @@
                                           CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments) {
     assert(isOpen);
     Selector selector =
         new Selector(SelectorKind.CALL, element.memberName, callStructure);
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector,
             arguments, k));
   }
+
+  @override
+  ir.Primitive buildReifyTypeVariable(TypeVariableType variable) {
+    return addPrimitive(new ir.ReifyTypeVar(variable.element));
+  }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
 
@@ skipping 207 matching lines @@
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
       ir.Primitive value = addPrimitive(new ir.GetField(box, location.field));
       add(new ir.SetField(newBox, location.field, value));
     }
     environment.update(scope.box, newBox);
   }
 
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
+    assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
   @override
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   @override
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
@@ skipping 49 matching lines @@
       arguments = new List<ir.Primitive>.from(arguments)
           ..addAll(typeArguments);
     }
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector,
             arguments, k));
   }
 
   ir.Primitive buildTypeExpression(DartType type) {
     if (type is TypeVariableType) {
-      return buildTypeVariableAccess(buildThis(), type);
+      return buildTypeVariableAccess(type);
     } else if (type is InterfaceType) {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       type.forEachTypeVariable((TypeVariableType variable) {
-        ir.Primitive value = buildTypeVariableAccess(buildThis(), variable);
+        ir.Primitive value = buildTypeVariableAccess(variable);
         arguments.add(value);
       });
       return addPrimitive(new ir.TypeExpression(type, arguments));
     } else {
       // TypedefType can reach here, and possibly other things.
       throw 'unimplemented translation of type expression $type';
     }
   }
 
-  ir.Primitive buildTypeVariableAccess(ir.Primitive target,
-                                       TypeVariableType variable) {
+  /// 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 (jsState.inInitializers) {
       return accessTypeArgumentParameter();
     } else {
+      ir.Primitive target = buildThis();
       return addPrimitive(new ir.ReadTypeVariable(variable, target));
     }
   }
+
+  @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) {
+    return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
+  }
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 60 matching lines @@
 }
 
 /// 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;
 }