Adding check or trust type checks to builder_kernel.dart.

pkg/compiler/lib/src/ssa/graph_builder.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 file.
 
+import '../closure.dart';
+import '../common.dart';
+import '../common/codegen.dart' show CodegenRegistry;
 import '../compiler.dart';
+import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js_backend/js_backend.dart';
 import '../resolution/tree_elements.dart';
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/use.dart' show TypeUse;
+import '../world.dart' show ClosedWorld;
 import 'jump_handler.dart';
 import 'locals_handler.dart';
 import 'nodes.dart';
 import 'ssa_branch_builder.dart';
+import 'type_verifier.dart';
 
 /// Base class for objects that build up an SSA graph.
 ///
 /// This contains helpers for building the graph and tracking information about
 /// the current state of the graph being built.
 abstract class GraphBuilder {
   /// Holds the resulting SSA graph.
   final HGraph graph = new HGraph();
 
   // TODO(het): remove this
   /// A reference to the compiler.
   Compiler compiler;
 
   /// The JavaScript backend we are targeting in this compilation.
   JavaScriptBackend get backend;
 
   /// The tree elements for the element being built into an SSA graph.
   TreeElements get elements;
 
+  CodegenRegistry get registry;
+
   /// Used to track the locals while building the graph.
   LocalsHandler localsHandler;
 
   /// A stack of instructions.
   ///
   /// We build the SSA graph by simulating a stack machine.
   List<HInstruction> stack = <HInstruction>[];
 
   /// The count of nested loops we are currently building.
   ///
@@ skipping 130 matching lines @@
 
   HSubGraphBlockInformation wrapStatementGraph(SubGraph statements) {
     if (statements == null) return null;
     return new HSubGraphBlockInformation(statements);
   }
 
   HSubExpressionBlockInformation wrapExpressionGraph(SubExpression expression) {
     if (expression == null) return null;
     return new HSubExpressionBlockInformation(expression);
   }
+
+  HInstruction buildFunctionType(FunctionType type) {
+    type.accept(new TypeBuilder(compiler.closedWorld), this);
+    return pop();
+  }
+
+  HInstruction buildFunctionTypeConversion(HInstruction original,
+      DartType type, int kind);
+
+  /// Returns the current source element.
+  ///
+  /// The returned element is a declaration element.
+  Element get sourceElement;
+
+  // 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;
+  }
+
+  /// The element for which this SSA builder is being used.
+  Element get targetElement;
+  TypeVerifier get typeVerifier;
 }
+
+class TypeBuilder implements DartTypeVisitor<dynamic, GraphBuilder> {

[sra1, 2016/11/12 00:31:19]

There is a lot of duplication here. Is it necessary (is DartType here different
to DartType in the ssa/builder.dart version?

[Emily Fortuna, 2016/11/14 17:47:56]

sorry I hadn't cut the code from builder.dart. the code is indeed identical but
I intended to move it here.

+  final ClosedWorld closedWorld;
+
+  TypeBuilder(this.closedWorld);
+
+  void visit(DartType type, GraphBuilder builder) => type.accept(this, builder);
+
+  void visitVoidType(VoidType type, GraphBuilder builder) {
+    ClassElement cls = builder.backend.helpers.VoidRuntimeType;
+    builder.push(new HVoidType(type, new TypeMask.exact(cls, closedWorld)));
+  }
+
+  void visitTypeVariableType(TypeVariableType type, GraphBuilder 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.typeVerifier.addTypeVariableReference(
+            type, builder.sourceElement),
+          instructionType));
+    }
+  }
+
+  void visitFunctionType(FunctionType type, GraphBuilder 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);
+      inputs.add(builder.pop());
+    }
+
+    for (DartType parameter in type.optionalParameterTypes) {
+      parameter.accept(this, builder);
+      inputs.add(builder.pop());
+    }
+
+    List<DartType> namedParameterTypes = type.namedParameterTypes;
+    List<String> names = type.namedParameters;
+    for (int index = 0; index < names.length; index++) {
+      ast.DartString dartString = new ast.DartString.literal(names[index]);
+      inputs.add(builder.graph.addConstantString(dartString, builder.compiler));
+      namedParameterTypes[index].accept(this, builder);
+      inputs.add(builder.pop());
+    }
+
+    ClassElement cls = builder.backend.helpers.RuntimeFunctionType;
+    builder.push(
+        new HFunctionType(inputs, type, new TypeMask.exact(cls, closedWorld)));
+  }
+
+  void visitMalformedType(MalformedType type, GraphBuilder builder) {
+    visitDynamicType(const DynamicType(), builder);
+  }
+
+  void visitStatementType(StatementType type, GraphBuilder builder) {
+    throw 'not implemented visitStatementType($type)';
+  }
+
+  void visitInterfaceType(InterfaceType type, GraphBuilder builder) {
+    List<HInstruction> inputs = <HInstruction>[];
+    for (DartType typeArgument in type.typeArguments) {
+      typeArgument.accept(this, builder);
+      inputs.add(builder.pop());
+    }
+    ClassElement cls;
+    if (type.typeArguments.isEmpty) {
+      cls = builder.backend.helpers.RuntimeTypePlain;
+    } else {
+      cls = builder.backend.helpers.RuntimeTypeGeneric;
+    }
+    builder.push(
+        new HInterfaceType(inputs, type, new TypeMask.exact(cls, closedWorld)));
+  }
+
+  void visitTypedefType(TypedefType type, GraphBuilder builder) {
+    DartType unaliased = type.unaliased;
+    if (unaliased is TypedefType) throw 'unable to unalias $type';
+    unaliased.accept(this, builder);
+  }
+
+  void visitDynamicType(DynamicType type, GraphBuilder builder) {
+    JavaScriptBackend backend = builder.compiler.backend;
+    ClassElement cls = backend.helpers.DynamicRuntimeType;
+    builder.push(new HDynamicType(type, new TypeMask.exact(cls, closedWorld)));
+  }
+}