Adding check or trust type checks to builder_kernel.dart.

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 18 matching lines @@
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask, NativeEmitter;
 import '../native/native.dart' as native;
 import '../resolution/operators.dart';
 import '../resolution/semantic_visitor.dart';
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
-import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
+import '../universe/use.dart' show DynamicUse, StaticUse;
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld;
 
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'optimize.dart';
 import 'ssa_branch_builder.dart';
+import 'type_verifier.dart';
 import 'types.dart';
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
   final Compiler compiler;
 
   String get name => 'SSA builder';
 
@@ skipping 121 matching lines @@
   /// Returns `true` if the current element is an `async` function.
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
         element.asyncMarker == AsyncMarker.ASYNC);
   }
 
   /// Handles the building of loops.
   LoopHandler<ast.Node> loopHandler;
 
+  /// Handles type check building.
+  TypeVerifier typeVerifier;
+
   // TODO(sigmund): make most args optional
   SsaBuilder(
       this.target,
       this.resolvedAst,
       this.registry,
       JavaScriptBackend backend,
       this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
       : this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
         this.rti = backend.rti,
         this.inferenceResults = backend.compiler.globalInference.results {
     assert(target.isImplementation);
     compiler = backend.compiler;
     elementInferenceResults = _resultOf(target);
     assert(elementInferenceResults != null);
     graph.element = target;
     sourceElementStack.add(target);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     localsHandler = new LocalsHandler(this, target, null, compiler);
     loopHandler = new SsaLoopHandler(this);
+    typeVerifier = new TypeVerifier(this);
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
+  Element get targetElement => target;
+
   /// Reference to resolved elements in [target]'s AST.
   TreeElements get elements => resolvedAst.elements;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
   void visitNode(ast.Node node) {
     internalError(node, "Unhandled node: $node");
   }
 
   @override
   void apply(ast.Node node, [_]) {
     node.accept(this);
   }
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
+  @override
   Element get sourceElement => sourceElementStack.last;
 
   /// Helper to retrieve global inference results for [element] with special
   /// care for `ConstructorBodyElement`s which don't exist at the time the
   /// global analysis run.
   ///
   /// Note: this helper is used selectively. When we know that we are in a
   /// context were we don't expect to see a constructor body element, we
   /// directly fetch the data from the global inference results.
   GlobalTypeInferenceElementResult _resultOf(AstElement element) =>
       inferenceResults.resultOf(
           element is ConstructorBodyElementX ? element.constructor : element);
 
-  bool get _checkOrTrustTypes =>
-      compiler.options.enableTypeAssertions ||
-      compiler.options.trustTypeAnnotations;
-
   /// Build the graph for [target].
   HGraph build() {
     assert(invariant(target, target.isImplementation));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
       result = buildFactory(resolvedAst);
     } else if (target.isGenerativeConstructorBody ||
@@ skipping 13 matching lines @@
       reporter.internalError(target, 'Unexpected element kind $target.');
     }
     assert(result.isValid());
     return result;
   }
 
   void addWithPosition(HInstruction instruction, ast.Node node) {
     add(attachPosition(instruction, node));
   }
 
+  HTypeConversion buildFunctionTypeConversion(HInstruction original,
+      DartType type, int kind) {
+    String name =
+        kind == HTypeConversion.CAST_TYPE_CHECK ? '_asCheck' : '_assertCheck';
+
+    List<HInstruction> arguments = <HInstruction>[
+      buildFunctionType(type),
+      original
+    ];
+    pushInvokeDynamic(
+        null,
+        new Selector.call(
+            new Name(name, helpers.jsHelperLibrary), CallStructure.ONE_ARG),
+        null,
+        arguments);
+
+    return new HTypeConversion(type, kind, original.instructionType, pop());
+  }
+
   /**
    * Returns a complete argument list for a call of [function].
    */
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
     assert(invariant(function, function.isImplementation));
     assert(providedArguments != null);
@@ skipping 437 matching lines @@
     ResolvedAst resolvedAst = field.resolvedAst;
     openFunction(field, resolvedAst.node);
     HInstruction thisInstruction = localsHandler.readThis();
     // Use dynamic type because the type computed by the inferrer is
     // narrowed to the type annotation.
     HInstruction parameter = new HParameterValue(field, backend.dynamicType);
     // Add the parameter as the last instruction of the entry block.
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
-    HInstruction value = potentiallyCheckOrTrustType(parameter, field.type);
+    HInstruction value = typeVerifier.potentiallyCheckOrTrustType(
+        parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     assert(invariant(variable, resolvedAst.element == variable,
         message: "Unexpected variable $variable for $resolvedAst."));
     inLazyInitializerExpression = true;
     ast.VariableDefinitions node = resolvedAst.node;
     ast.Node initializer = resolvedAst.body;
     assert(invariant(variable, initializer != null,
         message: "Non-constant variable $variable has no initializer."));
     openFunction(variable, node);
     visit(initializer);
     HInstruction value = pop();
-    value = potentiallyCheckOrTrustType(value, variable.type);
+    value = typeVerifier.potentiallyCheckOrTrustType(value, variable.type);
     // In the case of multiple declarations (and some definitions) on the same
     // line, the source pointer needs to point to the right initialized
     // variable. So find the specific initialized variable we are referring to.
     ast.Node sourceInfoNode = initializer;
     for (var definition in node.definitions) {
       if (definition is ast.SendSet &&
           definition.selector.asIdentifier().source == variable.name) {
         sourceInfoNode = definition.assignmentOperator;
         break;
       }
@@ skipping 111 matching lines @@
     elementInferenceResults = state.oldElementInferenceResults;
     returnType = state.oldReturnType;
     assert(stack.isEmpty);
     stack = state.oldStack;
   }
 
   /**
    * Run this builder on the body of the [function] to be inlined.
    */
   void visitInlinedFunction(ResolvedAst resolvedAst) {
-    potentiallyCheckInlinedParameterTypes(resolvedAst.element.implementation);
+    typeVerifier.potentiallyCheckInlinedParameterTypes(
+        resolvedAst.element.implementation);
 
     if (resolvedAst.element.isGenerativeConstructor) {
       buildFactory(resolvedAst);
     } else {
       ast.FunctionExpression functionNode = resolvedAst.node;
       functionNode.body.accept(this);
     }
   }
 
   addInlinedInstantiation(DartType type) {
@@ skipping 12 matching lines @@
     /* When inlining the iterator methods generated for a [:for-in:] loop, the
      * [currentNode] is the [ForIn] tree. The compiler-generated iterator
      * invocations are known to have fully specified argument lists, no default
      * arguments are used. See invocations of [pushInvokeDynamic] in
      * [visitForIn].
      */
     return currentNode.asForIn() != null;
   }
 
   /**
-   * In checked mode, generate type tests for the parameters of the inlined
-   * function.
-   */
-  void potentiallyCheckInlinedParameterTypes(FunctionElement function) {
-    if (!_checkOrTrustTypes) return;
-
-    FunctionSignature signature = function.functionSignature;
-    signature.orderedForEachParameter((ParameterElement parameter) {
-      HInstruction argument = localsHandler.readLocal(parameter);
-      potentiallyCheckOrTrustType(argument, parameter.type);
-    });
-  }
-
-  /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(
       ResolvedAst constructorResolvedAst,
       List<HInstruction> compiledArguments,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues,
       FunctionElement caller) {
@@ skipping 14 matching lines @@
         List<DartType> arguments = type.typeArguments;
         List<DartType> typeVariables = enclosingClass.typeVariables;
         if (!type.isRaw) {
           assert(arguments.length == typeVariables.length);
           Iterator<DartType> variables = typeVariables.iterator;
           type.typeArguments.forEach((DartType argument) {
             variables.moveNext();
             TypeVariableType typeVariable = variables.current;
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(typeVariable),
-                analyzeTypeArgument(argument));
+                typeVerifier.analyzeTypeArgument(argument, sourceElement));
           });
         } else {
           // If the supertype is a raw type, we need to set to null the
           // type variables.
           for (TypeVariableType variable in typeVariables) {
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(variable),
                 graph.addConstantNull(compiler));
           }
         }
@@ skipping 281 matching lines @@
         (ClassElement enclosingClass, FieldElement member) {
       HInstruction value = fieldValues[member];
       if (value == null) {
         // Uninitialized native fields are pre-initialized by the native
         // implementation.
         assert(invariant(
             member, isNativeUpgradeFactory || compiler.compilationFailed));
       } else {
         fields.add(member);
         DartType type = localsHandler.substInContext(member.type);
-        constructorArguments.add(potentiallyCheckOrTrustType(value, type));
+        constructorArguments.add(typeVerifier.potentiallyCheckOrTrustType(
+              value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.thisType;
     TypeMask ssaType = new TypeMask.nonNullExact(
         classElement.declaration, compiler.closedWorld);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
@@ skipping 178 matching lines @@
           //     class A {
           //       A(String foo) = A.b;
           //       A(int foo) { print(foo); }
           //     }
           //     main() {
           //       new A(499);    // valid even in checked mode.
           //       new A("foo");  // invalid in checked mode.
           //
           // Only the final target is allowed to check for the argument types.
           newParameter =
-              potentiallyCheckOrTrustType(newParameter, parameterElement.type);
+              typeVerifier.potentiallyCheckOrTrustType(
+                  newParameter, parameterElement.type);
         }
         localsHandler.directLocals[parameterElement] = newParameter;
       });
 
       returnType = signature.type.returnType;
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
 
@@ skipping 17 matching lines @@
     if (JavaScriptBackend.TRACE_METHOD == 'post') {
       if (element == backend.traceHelper) return;
       // TODO(sigmund): create a better uuid for elements.
       HConstant idConstant = graph.addConstantInt(element.hashCode, compiler);
       HConstant nameConstant = addConstantString(element.name);
       add(new HInvokeStatic(backend.traceHelper,
           <HInstruction>[idConstant, nameConstant], backend.dynamicType));
     }
   }
 
-  /// Check that [type] is valid in the context of `localsHandler.contextClass`.
-  /// This should only be called in assertions.
-  bool assertTypeInContext(DartType type, [Spannable spannable]) {
-    return invariant(spannable == null ? CURRENT_ELEMENT_SPANNABLE : spannable,
-        () {
-      ClassElement contextClass = Types.getClassContext(type);
-      return contextClass == null || contextClass == localsHandler.contextClass;
-    },
-        message: "Type '$type' is not valid context of "
-            "${localsHandler.contextClass}.");
-  }
-
-  /// Build a [HTypeConversion] for converting [original] to type [type].
-  ///
-  /// Invariant: [type] must be valid in the context.
-  /// See [LocalsHandler.substInContext].
-  HInstruction buildTypeConversion(
-      HInstruction original, DartType type, int kind) {
-    if (type == null) return original;
-    // GENERIC_METHODS: The following statement was added for parsing and
-    // ignoring method type variables; must be generalized for full support of
-    // generic methods.
-    type = type.dynamifyMethodTypeVariableType;
-    type = type.unaliased;
-    assert(assertTypeInContext(type, original));
-    if (type.isInterfaceType && !type.treatAsRaw) {
-      TypeMask subtype =
-          new TypeMask.subtype(type.element, compiler.closedWorld);
-      HInstruction representations = buildTypeArgumentRepresentations(type);
-      add(representations);
-      return new HTypeConversion.withTypeRepresentation(
-          type, kind, subtype, original, representations);
-    } else if (type.isTypeVariable) {
-      TypeMask subtype = original.instructionType;
-      HInstruction typeVariable = addTypeVariableReference(type);
-      return new HTypeConversion.withTypeRepresentation(
-          type, kind, subtype, original, typeVariable);
-    } else if (type.isFunctionType) {
-      String name =
-          kind == HTypeConversion.CAST_TYPE_CHECK ? '_asCheck' : '_assertCheck';
-
-      List<HInstruction> arguments = <HInstruction>[
-        buildFunctionType(type),
-        original
-      ];
-      pushInvokeDynamic(
-          null,
-          new Selector.call(
-              new Name(name, helpers.jsHelperLibrary), CallStructure.ONE_ARG),
-          null,
-          arguments);
-
-      return new HTypeConversion(type, kind, original.instructionType, pop());
-    } else {
-      return original.convertType(compiler, type, kind);
-    }
-  }
-
-  HInstruction _trustType(HInstruction original, DartType type) {
-    assert(compiler.options.trustTypeAnnotations);
-    assert(type != null);
-    type = localsHandler.substInContext(type);
-    type = type.unaliased;
-    if (type.isDynamic) return original;
-    if (!type.isInterfaceType) return original;
-    if (type.isObject) return original;
-    // The type element is either a class or the void element.
-    Element element = type.element;
-    TypeMask mask = new TypeMask.subtype(element, compiler.closedWorld);
-    return new HTypeKnown.pinned(mask, original);
-  }
-
-  HInstruction _checkType(HInstruction original, DartType type, int kind) {
-    assert(compiler.options.enableTypeAssertions);
-    assert(type != null);
-    type = localsHandler.substInContext(type);
-    HInstruction other = buildTypeConversion(original, type, kind);
-    // TODO(johnniwinther): This operation on `registry` may be inconsistent.
-    // If it is needed then it seems likely that similar invocations of
-    // `buildTypeConversion` in `SsaBuilder.visitAs` should also be followed by
-    // a similar operation on `registry`; otherwise, this one might not be
-    // needed.
-    registry?.registerTypeUse(new TypeUse.isCheck(type));
-    return other;
-  }
-
-  HInstruction potentiallyCheckOrTrustType(HInstruction original, DartType type,
-      {int kind: HTypeConversion.CHECKED_MODE_CHECK}) {
-    if (type == null) return original;
-    HInstruction checkedOrTrusted = original;
-    if (compiler.options.trustTypeAnnotations) {
-      checkedOrTrusted = _trustType(original, type);
-    } else if (compiler.options.enableTypeAssertions) {
-      checkedOrTrusted = _checkType(original, type, kind);
-    }
-    if (checkedOrTrusted == original) return original;
-    add(checkedOrTrusted);
-    return checkedOrTrusted;
-  }
-
   void assertIsSubtype(
       ast.Node node, DartType subtype, DartType supertype, String message) {
     HInstruction subtypeInstruction =
-        analyzeTypeArgument(localsHandler.substInContext(subtype));
-    HInstruction supertypeInstruction =
-        analyzeTypeArgument(localsHandler.substInContext(supertype));
+        typeVerifier.analyzeTypeArgument(localsHandler.substInContext(subtype),
+            sourceElement);
+    HInstruction supertypeInstruction = typeVerifier.analyzeTypeArgument(
+        localsHandler.substInContext(supertype), sourceElement);
     HInstruction messageInstruction =
         graph.addConstantString(new ast.DartString.literal(message), compiler);
     MethodElement element = helpers.assertIsSubtype;
     var inputs = <HInstruction>[
       subtypeInstruction,
       supertypeInstruction,
       messageInstruction
     ];
     HInstruction assertIsSubtype =
         new HInvokeStatic(element, inputs, subtypeInstruction.instructionType);
     registry?.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
     add(assertIsSubtype);
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
     return graph;
   }
 
   void pushWithPosition(HInstruction instruction, ast.Node node) {
     push(attachPosition(instruction, node));
   }
 
+  /// Pops the most recent instruction from the stack and 'boolifies' it.
+  ///
+  /// Boolification is checking if the value is '=== true'.
   @override
   HInstruction popBoolified() {
     HInstruction value = pop();
-    if (_checkOrTrustTypes) {
-      return potentiallyCheckOrTrustType(value, compiler.coreTypes.boolType,
+    if (typeVerifier.checkOrTrustTypes) {
+      return typeVerifier.potentiallyCheckOrTrustType(
+          value, compiler.coreTypes.boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, backend.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
     if (node != null) {
       target.sourceInformation = sourceInformationBuilder.buildGeneric(node);
@@ skipping 770 matching lines @@
     }
     assert(invariant(
         location, send == null || !Elements.isInstanceSend(send, elements),
         message: "Unexpected non instance setter: $element."));
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter) {
         pushInvokeStatic(location, element, <HInstruction>[value]);
         pop();
       } else {
         FieldElement field = element;
-        value = potentiallyCheckOrTrustType(value, field.type);
+        value = typeVerifier.potentiallyCheckOrTrustType(value, field.type);
         addWithPosition(new HStaticStore(field, value), location);
       }
       stack.add(value);
     } else if (Elements.isError(element)) {
       generateNoSuchSetter(location, element, send == null ? null : value);
     } else if (Elements.isMalformed(element)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
     } else {
       stack.add(value);
       LocalElement local = element;
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = local;
       }
       HInstruction checkedOrTrusted =
-          potentiallyCheckOrTrustType(value, local.type);
+          typeVerifier.potentiallyCheckOrTrustType(value, local.type);
       if (!identical(checkedOrTrusted, value)) {
         pop();
         stack.add(checkedOrTrusted);
       }
 
       localsHandler.updateLocal(local, checkedOrTrusted,
           sourceInformation:
               sourceInformationBuilder.buildAssignment(location));
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, backend.extendableArrayType);
   }
 
-  HInstruction buildTypeArgumentRepresentations(DartType type) {
-    assert(!type.isTypeVariable);
-    // Compute the representation of the type arguments, including access
-    // to the runtime type information for type variables as instructions.
-    assert(type.element.isClass);
-    InterfaceType interface = type;
-    List<HInstruction> inputs = <HInstruction>[];
-    for (DartType argument in interface.typeArguments) {
-      inputs.add(analyzeTypeArgument(argument));
-    }
-    HInstruction representation = new HTypeInfoExpression(
-        TypeInfoExpressionKind.INSTANCE,
-        interface.element.thisType,
-        inputs,
-        backend.dynamicType);
-    return representation;
-  }
-
   @override
   void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     if (type.isMalformed) {
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         generateTypeError(node, element.message);
       } else {
         assert(type is MethodTypeVariableType);
         stack.add(expressionInstruction);
       }
     } else {
-      HInstruction converted = buildTypeConversion(expressionInstruction,
-          localsHandler.substInContext(type), HTypeConversion.CAST_TYPE_CHECK);
+      HInstruction converted = typeVerifier.buildTypeConversion(
+          expressionInstruction, localsHandler.substInContext(type),
+          HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) add(converted);
       stack.add(converted);
     }
   }
 
   @override
   void visitIs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     push(buildIsNode(node, type, expressionInstruction));
   }
@@ skipping 25 matching lines @@
     } else if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node,
           new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
-      HInstruction runtimeType = addTypeVariableReference(type);
+      HInstruction runtimeType = typeVerifier.addTypeVariableReference(
+          type, sourceElement);
       Element helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
       Element helper = helpers.checkSubtype;
-      HInstruction representations = buildTypeArgumentRepresentations(type);
+      HInstruction representations =
+          typeVerifier.buildTypeArgumentRepresentations(type, sourceElement);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = compiler.closedWorld
               .hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       pushInvokeStatic(node, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
         return new HIs.direct(type, expression, backend.boolType);
       }
       // The interceptor is not always needed.  It is removed by optimization
       // when the receiver type or tested type permit.
       return new HIs.raw(
           type, expression, invokeInterceptor(expression), backend.boolType);
     }
   }
 
-  HInstruction buildFunctionType(FunctionType type) {
-    type.accept(new TypeBuilder(compiler.closedWorld), this);
-    return pop();
-  }
-
   void addDynamicSendArgumentsToList(ast.Send node, List<HInstruction> list) {
     CallStructure callStructure = elements.getSelector(node).callStructure;
     if (callStructure.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<ast.Node> arguments = node.arguments;
       int positionalArgumentCount = callStructure.positionalArgumentCount;
       for (int i = 0;
           i < positionalArgumentCount;
@@ skipping 766 matching lines @@
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     ClosedWorld closedWorld = compiler.closedWorld;
     if (closedWorld.isUsedAsMixin(cls)) return true;
 
     return compiler.closedWorld.anyStrictSubclassOf(cls,
         (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
-  /**
-   * Generate code to extract the type argument from the object.
-   */
-  HInstruction readTypeVariable(TypeVariableType variable,
-      {SourceInformation sourceInformation}) {
-    assert(sourceElement.isInstanceMember);
-    assert(variable is! MethodTypeVariableType);
-    HInstruction target = localsHandler.readThis();
-    push(new HTypeInfoReadVariable(variable, target, backend.dynamicType)
-      ..sourceInformation = sourceInformation);
-    return pop();
-  }
-
-  // TODO(karlklose): this is needed to avoid a bug where the resolved type is
-  // not stored on a type annotation in the closure translator. Remove when
-  // fixed.
-  bool hasDirectLocal(Local local) {
-    return !localsHandler.isAccessedDirectly(local) ||
-        localsHandler.directLocals[local] != null;
-  }
-
-  /**
-   * Helper to create an instruction that gets the value of a type variable.
-   */
-  HInstruction addTypeVariableReference(TypeVariableType type,
-      {SourceInformation sourceInformation}) {
-    assert(assertTypeInContext(type));
-    if (type is MethodTypeVariableType) {
-      return graph.addConstantNull(compiler);
-    }
-    Element member = sourceElement;
-    bool isClosure = member.enclosingElement.isClosure;
-    if (isClosure) {
-      ClosureClassElement closureClass = member.enclosingElement;
-      member = closureClass.methodElement;
-      member = member.outermostEnclosingMemberOrTopLevel;
-    }
-    bool isInConstructorContext =
-        member.isConstructor || member.isGenerativeConstructorBody;
-    Local typeVariableLocal = localsHandler.getTypeVariableAsLocal(type);
-    if (isClosure) {
-      if (member.isFactoryConstructor ||
-          (isInConstructorContext && hasDirectLocal(typeVariableLocal))) {
-        // The type variable is used from a closure in a factory constructor.
-        // The value of the type argument is stored as a local on the closure
-        // itself.
-        return localsHandler.readLocal(typeVariableLocal,
-            sourceInformation: sourceInformation);
-      } else if (member.isFunction ||
-          member.isGetter ||
-          member.isSetter ||
-          isInConstructorContext) {
-        // The type variable is stored on the "enclosing object" and needs to be
-        // accessed using the this-reference in the closure.
-        return readTypeVariable(type, sourceInformation: sourceInformation);
-      } else {
-        assert(member.isField);
-        // The type variable is stored in a parameter of the method.
-        return localsHandler.readLocal(typeVariableLocal);
-      }
-    } else if (isInConstructorContext ||
-        // When [member] is a field, we can be either
-        // generating a checked setter or inlining its
-        // initializer in a constructor. An initializer is
-        // never built standalone, so in that case [target] is not
-        // the [member] itself.
-        (member.isField && member != target)) {
-      // The type variable is stored in a parameter of the method.
-      return localsHandler.readLocal(typeVariableLocal,
-          sourceInformation: sourceInformation);
-    } else if (member.isInstanceMember) {
-      // The type variable is stored on the object.
-      return readTypeVariable(type, sourceInformation: sourceInformation);
-    } else {
-      reporter.internalError(
-          type.element, 'Unexpected type variable in static context.');
-      return null;
-    }
-  }
-
-  HInstruction analyzeTypeArgument(DartType argument,
-      {SourceInformation sourceInformation}) {
-    assert(assertTypeInContext(argument));
-    argument = argument.unaliased;
-    if (argument.treatAsDynamic) {
-      // Represent [dynamic] as [null].
-      return graph.addConstantNull(compiler);
-    }
-
-    if (argument.isTypeVariable) {
-      return addTypeVariableReference(argument,
-          sourceInformation: sourceInformation);
-    }
-
-    List<HInstruction> inputs = <HInstruction>[];
-    argument.forEachTypeVariable((variable) {
-      if (variable is! MethodTypeVariableType) {
-        inputs.add(analyzeTypeArgument(variable));
-      }
-    });
-    HInstruction result = new HTypeInfoExpression(
-        TypeInfoExpressionKind.COMPLETE, argument, inputs, backend.dynamicType)
-      ..sourceInformation = sourceInformation;
-    add(result);
-    return result;
-  }
-
   HInstruction handleListConstructor(
       InterfaceType type, ast.Node currentNode, HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((DartType argument) {
-      inputs.add(analyzeTypeArgument(argument));
+      inputs.add(typeVerifier.analyzeTypeArgument(argument, sourceElement));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(
         type.element, inputs, newObject);
   }
 
   HInstruction callSetRuntimeTypeInfoWithTypeArguments(ClassElement element,
       List<HInstruction> rtiInputs, HInstruction newObject) {
     if (!backend.classNeedsRti(element)) {
@@ skipping 227 matching lines @@
     if (backend.classNeedsRti(coreClasses.listClass) &&
         (isFixedListConstructorCall ||
             isGrowableListConstructorCall ||
             isJSArrayTypedConstructor)) {
       newInstance = handleListConstructor(type, send, pop());
       stack.add(newInstance);
     }
 
     // Finally, if we called a redirecting factory constructor, check the type.
     if (isRedirected) {
-      HInstruction checked = potentiallyCheckOrTrustType(newInstance, type);
+      HInstruction checked = typeVerifier.potentiallyCheckOrTrustType(
+          newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
   void potentiallyAddTypeArguments(
       List<HInstruction> inputs, ClassElement cls, InterfaceType expectedType,
       {SourceInformation sourceInformation}) {
     if (!backend.classNeedsRti(cls)) return;
     assert(cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((DartType argument) {
       inputs.add(
-          analyzeTypeArgument(argument, sourceInformation: sourceInformation));
+          typeVerifier.analyzeTypeArgument(argument, sourceElement,
+            sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
     if (!compiler.options.enableTypeAssertions) return false;
 
     Map<DartType, Set<DartType>> seenChecksMap =
         new Map<DartType, Set<DartType>>();
@@ skipping 251 matching lines @@
   /// Generate the literal for [typeVariable] in the current context.
   void generateTypeVariableLiteral(
       ast.Send node, TypeVariableType typeVariable) {
     // GENERIC_METHODS: This provides thin support for method type variables
     // by treating them as malformed when evaluated as a literal. For full
     // support of generic methods this must be revised.
     if (typeVariable is MethodTypeVariableType) {
       generateTypeError(node, "Method type variables are not reified");
     } else {
       DartType type = localsHandler.substInContext(typeVariable);
-      HInstruction value = analyzeTypeArgument(type,
+      HInstruction value = typeVerifier.analyzeTypeArgument(type, sourceElement,
           sourceInformation: sourceInformationBuilder.buildGet(node));
       pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
           typeMask: backend.stringType);
       pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
     }
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
     // This send is of the form 'e(...)', where e is resolved to a type
@@ skipping 1305 matching lines @@
       }
     }
 
     ClassElement targetClass = targetConstructor.enclosingClass;
     if (backend.classNeedsRti(targetClass)) {
       ClassElement cls = redirectingConstructor.enclosingClass;
       InterfaceType targetType =
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
       targetType = localsHandler.substInContext(targetType);
       targetType.typeArguments.forEach((DartType argument) {
-        inputs.add(analyzeTypeArgument(argument));
+        inputs.add(typeVerifier.analyzeTypeArgument(argument, sourceElement));
       });
     }
     pushInvokeStatic(node, targetConstructor.declaration, inputs);
     HInstruction value = pop();
     emitReturn(value, node);
   }
 
   /// Returns true if the [type] is a valid return type for an asynchronous
   /// function.
   ///
@@ skipping 29 matching lines @@
       if (isBuildingAsyncFunction) {
         if (compiler.options.enableTypeAssertions &&
             !isValidAsyncReturnType(returnType)) {
           String message = "Async function returned a Future, "
               "was declared to return a $returnType.";
           generateTypeError(node, message);
           pop();
           return;
         }
       } else {
-        value = potentiallyCheckOrTrustType(value, returnType);
+        value = typeVerifier.potentiallyCheckOrTrustType(value, returnType);
       }
     }
 
     handleInTryStatement();
     emitReturn(value, node);
   }
 
   visitThrow(ast.Throw node) {
     visitThrowExpression(node.expression);
     if (isReachable) {
@@ skipping 41 matching lines @@
     }
   }
 
   HInstruction setRtiIfNeeded(HInstruction object, ast.Node node) {
     InterfaceType type = localsHandler.substInContext(elements.getType(node));
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (DartType argument in type.typeArguments) {
-      arguments.add(analyzeTypeArgument(argument));
+      arguments.add(typeVerifier.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(
         type.element, arguments, object);
   }
 
   visitLiteralList(ast.LiteralList node) {
     HInstruction instruction;
 
@@ skipping 427 matching lines @@
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         functionElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     ClassElement cls = constructor.enclosingClass;
 
     if (backend.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
       expectedType.typeArguments.forEach((DartType argument) {
-        typeInputs.add(analyzeTypeArgument(argument));
+        typeInputs.add(typeVerifier.analyzeTypeArgument(
+              argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (listInputs.isEmpty) {
           constructor = helpers.mapLiteralUntypedEmptyMaker;
         } else {
           constructor = helpers.mapLiteralUntypedMaker;
         }
@@ skipping 1078 matching lines @@
 
   void visitTypeVariableType(TypeVariableType type, SsaBuilder builder) {
     ClassElement cls = builder.backend.helpers.RuntimeType;
     TypeMask instructionType = new TypeMask.subclass(cls, closedWorld);
     if (!builder.sourceElement.enclosingElement.isClosure &&
         builder.sourceElement.isInstanceMember) {
       HInstruction receiver = builder.localsHandler.readThis();
       builder.push(new HReadTypeVariable(type, receiver, instructionType));
     } else {
       builder.push(new HReadTypeVariable.noReceiver(
-          type, builder.addTypeVariableReference(type), instructionType));
+          type, builder.typeVerifier.addTypeVariableReference(
+            type, builder.sourceElement), instructionType));
     }
   }
 
   void visitFunctionType(FunctionType type, SsaBuilder builder) {
     type.returnType.accept(this, builder);
     HInstruction returnType = builder.pop();
     List<HInstruction> inputs = <HInstruction>[returnType];
 
     for (DartType parameter in type.parameterTypes) {
       parameter.accept(this, builder);
@@ skipping 48 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.helpers.DynamicRuntimeType;
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, closedWorld)));
   }
 }