Add Resolution and Parsing interfaces for computeType, ensureResolved and parseNode.

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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 1087 matching lines @@
       this.rti = backend.rti,
       this.elements = work.resolutionTree {
     graph.element = work.element;
     localsHandler = new LocalsHandler(this, work.element, null);
     sourceElementStack.add(work.element);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(
             work.element.implementation);
   }
 
+  // TODO(johnniwinther): Avoid the need for this.
+  Resolution get resolution => compiler.resolution;
+
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
   void visitNode(ast.Node node) {
     internalError(node, "Unhandled node: $node");
   }
 
   @override
   void apply(ast.Node node, [_]) {
@@ skipping 1354 matching lines @@
   }
 
   /// Build a [HTypeConversion] for convertion [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;
-    type = type.unalias(compiler);
+    type = type.unalias(resolution);
     assert(assertTypeInContext(type, original));
     if (type.isInterfaceType && !type.treatAsRaw) {
       TypeMask subtype = new TypeMask.subtype(type.element, compiler.world);
       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);
@@ skipping 15 matching lines @@
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
     }
   }
 
   HInstruction _trustType(HInstruction original, DartType type) {
     assert(compiler.trustTypeAnnotations);
     assert(type != null);
     type = localsHandler.substInContext(type);
-    type = type.unalias(compiler);
+    type = type.unalias(resolution);
     if (type.isDynamic) return original;
     if (!type.isInterfaceType) return original;
     // The type element is either a class or the void element.
     Element element = type.element;
     if (element == compiler.objectClass) return original;
     TypeMask mask = new TypeMask.subtype(element, compiler.world);
     return new HTypeKnown.pinned(mask, original);
   }
 
   HInstruction _checkType(HInstruction original, DartType type, int kind) {
@@ skipping 1274 matching lines @@
   void visitIsNot(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     HInstruction instruction = buildIsNode(node, type, expressionInstruction);
     add(instruction);
     push(new HNot(instruction, backend.boolType));
   }
 
   HInstruction buildIsNode(ast.Node node,
                            DartType type,
                            HInstruction expression) {
-    type = localsHandler.substInContext(type).unalias(compiler);
+    type = localsHandler.substInContext(type).unalias(resolution);
     if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node,
           new Selector.call(
               new PrivateName('_isTest', backend.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
@@ skipping 5153 matching lines @@
     if (type.typeArguments.isEmpty) {
       cls = builder.backend.findHelper('RuntimeTypePlain');
     } else {
       cls = builder.backend.findHelper('RuntimeTypeGeneric');
     }
     builder.push(new HInterfaceType(inputs, type,
         new TypeMask.exact(cls, classWorld)));
   }
 
   void visitTypedefType(TypedefType type, SsaBuilder builder) {
-    DartType unaliased = type.unalias(builder.compiler);
+    DartType unaliased = type.unalias(builder.compiler.resolution);
     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.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }