Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/builder_kernel.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 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 83 matching lines @@
   final ResolvedAst resolvedAst;
   final ClosedWorld closedWorld;
   final CodegenRegistry registry;
 
   /// Helper accessor for all kernel function-like targets (Procedure,
   /// FunctionExpression, FunctionDeclaration) of the inner FunctionNode itself.
   /// If the current target is not a function-like target, _targetFunction will
   /// be null.
   ir.FunctionNode _targetFunction;
 
-  /// A stack of [DartType]s that have been seen during inlining of factory
-  /// constructors.  These types are preserved in [HInvokeStatic]s and
+  /// A stack of [ResolutionDartType]s that have been seen during inlining of
+  /// factory constructors.  These types are preserved in [HInvokeStatic]s and
   /// [HCreate]s inside the inline code and registered during code generation
   /// for these nodes.
   // TODO(karlklose): consider removing this and keeping the (substituted) types
   // of the type variables in an environment (like the [LocalsHandler]).
-  final List<DartType> currentImplicitInstantiations = <DartType>[];
+  final List<ResolutionDartType> currentImplicitInstantiations =
+      <ResolutionDartType>[];
 
   HInstruction rethrowableException;
 
   @override
   JavaScriptBackend get backend => compiler.backend;
 
   @override
   TreeElements get elements => resolvedAst.elements;
 
   SourceInformationBuilder sourceInformationBuilder;
@@ skipping 106 matching lines @@
     var enclosing = constructor.enclosingClass;
     if (backend.classNeedsRti(astAdapter.getElement(enclosing))) {
       ClassElement clsElement =
           astAdapter.getElement(constructor).enclosingElement;
       enclosing.typeParameters.forEach((ir.TypeParameter typeParameter) {
         var typeParamElement = astAdapter.getElement(typeParameter);
         HParameterValue param =
             addParameter(typeParamElement, commonMasks.nonNullType);
         // This is a little bit wacky (and n^2) until we make the localsHandler
         // take Kernel DartTypes instead of just the AST DartTypes.
-        var typeVariableType = clsElement.typeVariables
-            .firstWhere((TypeVariableType i) => i.name == typeParameter.name);
+        var typeVariableType = clsElement.typeVariables.firstWhere(
+            (ResolutionTypeVariableType i) => i.name == typeParameter.name);
         localsHandler.directLocals[
             localsHandler.getTypeVariableAsLocal(typeVariableType)] = param;
       });
     }
   }
 
   /// Builds generative constructors.
   ///
   /// Generative constructors are built in two stages.
   ///
@@ skipping 20 matching lines @@
       constructorArguments.add(value);
     }, includeSuperAndInjectedMembers: true);
 
     // TODO(het): If the class needs runtime type information, add it as a
     // constructor argument.
     HInstruction create = new HCreate(
         astAdapter.getClass(constructor.enclosingClass),
         constructorArguments,
         new TypeMask.nonNullExact(
             astAdapter.getClass(constructor.enclosingClass), closedWorld),
-        instantiatedTypes: <DartType>[
+        instantiatedTypes: <ResolutionDartType>[
           astAdapter.getClass(constructor.enclosingClass).thisType
         ],
         hasRtiInput: false);
 
     add(create);
 
     // Generate calls to the constructor bodies.
 
     closeAndGotoExit(new HReturn(create, null));
     closeFunction();
@@ skipping 113 matching lines @@
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     });
 
     // TODO(het): set the locals handler state as if we were inlining the
     // constructor.
     _buildInitializers(constructor, fieldValues);
   }
 
   HTypeConversion buildFunctionTypeConversion(
-      HInstruction original, DartType type, int kind) {
+      HInstruction original, ResolutionDartType type, int kind) {
     HInstruction reifiedType = buildFunctionType(type);
     return new HTypeConversion.viaMethodOnType(
         type, kind, original.instructionType, reifiedType, original);
   }
 
   /// Builds a SSA graph for FunctionNodes, found in FunctionExpressions and
   /// Procedures.
   void buildFunctionNode(ir.FunctionNode functionNode) {
     openFunction();
     if (functionNode.parent is ir.Procedure &&
         (functionNode.parent as ir.Procedure).kind ==
             ir.ProcedureKind.Factory) {
       _addClassTypeVariablesIfNeeded(functionNode.parent);
     }
     functionNode.body.accept(this);
     closeFunction();
   }
 
-  void addImplicitInstantiation(DartType type) {
+  void addImplicitInstantiation(ResolutionDartType type) {
     if (type != null) {
       currentImplicitInstantiations.add(type);
     }
   }
 
-  void removeImplicitInstantiation(DartType type) {
+  void removeImplicitInstantiation(ResolutionDartType type) {
     if (type != null) {
       currentImplicitInstantiations.removeLast();
     }
   }
 
   void openFunction() {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     Node function;
@@ skipping 478 matching lines @@
     handleIf(
         visitCondition: () => ifStatement.condition.accept(this),
         visitThen: () => ifStatement.then.accept(this),
         visitElse: () => ifStatement.otherwise?.accept(this));
   }
 
   @override
   void visitAsExpression(ir.AsExpression asExpression) {
     asExpression.operand.accept(this);
     HInstruction expressionInstruction = pop();
-    DartType type = astAdapter.getDartType(asExpression.type);
+    ResolutionDartType type = astAdapter.getDartType(asExpression.type);
     if (type.isMalformed) {
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         generateTypeError(asExpression, element.message);
       } else {
         assert(type is MethodTypeVariableType);
         stack.add(expressionInstruction);
       }
     } else {
       HInstruction converted = typeBuilder.buildTypeConversion(
@@ skipping 144 matching lines @@
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   /// Set the runtime type information if necessary.
   HInstruction setListRuntimeTypeInfoIfNeeded(
       HInstruction object, ir.ListLiteral listLiteral) {
-    InterfaceType type = localsHandler
+    ResolutionInterfaceType type = localsHandler
         .substInContext(astAdapter.getDartTypeOfListLiteral(listLiteral));
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
-    for (DartType argument in type.typeArguments) {
+    for (ResolutionDartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
 
   @override
   void visitListLiteral(ir.ListLiteral listLiteral) {
     HInstruction listInstruction;
@@ skipping 45 matching lines @@
     } else {
       constructor = astAdapter.mapLiteralConstructor;
       HLiteralList argList =
           new HLiteralList(constructorArgs, commonMasks.extendableArrayType);
       add(argList);
       inputs.add(argList);
     }
 
     assert(constructor.kind == ir.ProcedureKind.Factory);
 
-    InterfaceType type = localsHandler
+    ResolutionInterfaceType type = localsHandler
         .substInContext(astAdapter.getDartTypeOfMapLiteral(mapLiteral));
 
     ir.Class cls = constructor.enclosingClass;
 
     if (backend.classNeedsRti(astAdapter.getElement(cls))) {
       List<HInstruction> typeInputs = <HInstruction>[];
-      type.typeArguments.forEach((DartType argument) {
+      type.typeArguments.forEach((ResolutionDartType argument) {
         typeInputs
             .add(typeBuilder.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 (constructorArgs.isEmpty) {
           constructor = astAdapter.mapLiteralUntypedEmptyMaker;
         } else {
@@ skipping 36 matching lines @@
   @override
   void visitTypeLiteral(ir.TypeLiteral typeLiteral) {
     ir.DartType type = typeLiteral.type;
     if (type is ir.InterfaceType) {
       ConstantValue constant = astAdapter.getConstantForType(type);
       stack.add(graph.addConstant(constant, closedWorld));
       return;
     }
     if (type is ir.TypeParameterType) {
       // TODO(sra): Convert the type logic here to use ir.DartType.
-      DartType dartType = astAdapter.getDartType(type);
+      ResolutionDartType dartType = astAdapter.getDartType(type);
       dartType = localsHandler.substInContext(dartType);
       HInstruction value = typeBuilder.analyzeTypeArgument(
           dartType, sourceElement,
           sourceInformation: null);
       _pushStaticInvocation(astAdapter.runtimeTypeToString,
           <HInstruction>[value], commonMasks.stringType);
       _pushStaticInvocation(astAdapter.createRuntimeType, <HInstruction>[pop()],
           astAdapter.createRuntimeTypeReturnType);
       return;
     }
@@ skipping 676 matching lines @@
     push(new HStringConcat(inputs[0], inputs[1], commonMasks.stringType));
   }
 
   void _pushStaticInvocation(
       ir.Node target, List<HInstruction> arguments, TypeMask typeMask) {
     HInvokeStatic instruction = new HInvokeStatic(
         astAdapter.getMember(target), arguments, typeMask,
         targetCanThrow: astAdapter.getCanThrow(target, closedWorld));
     if (currentImplicitInstantiations.isNotEmpty) {
       instruction.instantiatedTypes =
-          new List<DartType>.from(currentImplicitInstantiations);
+          new List<ResolutionDartType>.from(currentImplicitInstantiations);
     }
     instruction.sideEffects = astAdapter.getSideEffects(target, closedWorld);
 
     push(instruction);
   }
 
   void _pushDynamicInvocation(
       ir.Node node, TypeMask mask, List<HInstruction> arguments,
       {Selector selector}) {
     HInstruction receiver = arguments.first;
@@ skipping 160 matching lines @@
     isExpression.operand.accept(this);
     HInstruction expression = pop();
     push(buildIsNode(isExpression, isExpression.type, expression));
   }
 
   HInstruction buildIsNode(
       ir.Node node, ir.DartType type, HInstruction expression) {
     // Note: The call to "unalias" this type like in the original SSA builder is
     // unnecessary in kernel because Kernel has no notion of typedef.
     // TODO(efortuna): Add test for this.
-    DartType typeValue =
+    ResolutionDartType typeValue =
         localsHandler.substInContext(astAdapter.getDartType(type));
     if (type is ir.InvalidType) {
       generateTypeError(node, (typeValue.element as ErroneousElement).message);
       return new HIs.compound(
           typeValue, expression, pop(), commonMasks.boolType);
     }
 
     if (type is ir.FunctionType) {
       List arguments = [buildFunctionType(typeValue), expression];
       _pushDynamicInvocation(node, null, arguments,
@@ skipping 352 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }