Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/optimize.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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 452 matching lines @@
         &&
         node.selector.applies(element)) {
       MethodElement method = element;
 
       if (backend.isNative(method)) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
-        FunctionType type = method.type;
+        ResolutionFunctionType type = method.type;
         int optionalParameterCount =
             type.optionalParameterTypes.length + type.namedParameters.length;
         if (optionalParameterCount == 0 ||
-                type.parameterTypes.length + optionalParameterCount ==
+            type.parameterTypes.length + optionalParameterCount ==
                 node.selector.argumentCount) {
           node.element = method;
         }
       }
       return node;
     }
 
     // Replace method calls through fields with a closure call on the value of
     // the field. This usually removes the demand for the call-through stub and
     // makes the field load available to further optimization, e.g. LICM.
@@ skipping 33 matching lines @@
     // TODO(ngeoffray): There are some cases where we could still inline in
     // checked mode if we know the arguments have the right type. And we could
     // do the closure conversion as well as the return type annotation check.
 
     if (!node.isInterceptedCall) return null;
 
     // TODO(sra): Check for legacy methods with bodies in the native strings.
     //   foo() native 'return something';
     // They should not be used.
 
-    FunctionType type = method.type;
+    ResolutionFunctionType type = method.type;
     if (type.namedParameters.isNotEmpty) return null;
 
     // Return types on native methods don't need to be checked, since the
     // declaration has to be truthful.
 
     // The call site might omit optional arguments. The inlined code must
     // preserve the number of arguments, so check only the actual arguments.
 
     List<HInstruction> inputs = node.inputs.sublist(1);
     bool canInline = true;
     if (compiler.options.enableTypeAssertions && inputs.length > 1) {
       // TODO(sra): Check if [input] is guaranteed to pass the parameter
       // type check.  Consider using a strengthened type check to avoid
       // passing `null` to primitive types since the native methods usually
       // have non-nullable primitive parameter types.
       canInline = false;
     } else {
       int inputPosition = 1; // Skip receiver.
-      void checkParameterType(DartType type) {
+      void checkParameterType(ResolutionDartType type) {
         if (inputPosition++ < inputs.length && canInline) {
           if (type.unaliased.isFunctionType) {
             canInline = false;
           }
         }
       }
 
       type.parameterTypes.forEach(checkParameterType);
       type.optionalParameterTypes.forEach(checkParameterType);
       type.namedParameterTypes.forEach(checkParameterType);
@@ skipping 170 matching lines @@
         simplifyCondition(node.thenBlock, hoisted, false);
         simplifyCondition(node.elseBlock, hoisted, true);
       });
     }
     simplifyCondition(node.thenBlock, condition, !isNegated);
     simplifyCondition(node.elseBlock, condition, isNegated);
     return node;
   }
 
   HInstruction visitIs(HIs node) {
-    DartType type = node.typeExpression;
+    ResolutionDartType type = node.typeExpression;
 
     if (!node.isRawCheck) {
       return node;
     } else if (type.isTypedef) {
       return node;
     } else if (type.isFunctionType) {
       return node;
     }
 
     if (type.isObject || type.treatAsDynamic) {
       return graph.addConstantBool(true, closedWorld);
     }
-    InterfaceType interfaceType = type;
+    ResolutionInterfaceType interfaceType = type;
     ClassEntity element = interfaceType.element;
     HInstruction expression = node.expression;
     if (expression.isInteger(closedWorld)) {
       if (element == commonElements.intClass ||
           element == commonElements.numClass ||
           commonElements.isNumberOrStringSupertype(element)) {
         return graph.addConstantBool(true, closedWorld);
       } else if (element == commonElements.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
@@ skipping 38 matching lines @@
       if (expressionMask.union(typeMask, closedWorld) == typeMask) {
         return graph.addConstantBool(true, closedWorld);
       } else if (expressionMask.isDisjoint(typeMask, closedWorld)) {
         return graph.addConstantBool(false, closedWorld);
       }
     }
     return node;
   }
 
   HInstruction visitTypeConversion(HTypeConversion node) {
-    DartType type = node.typeExpression;
+    ResolutionDartType type = node.typeExpression;
     if (type != null) {
       if (type.isMalformed) {
         // Malformed types are treated as dynamic statically, but should
         // throw a type error at runtime.
         return node;
       }
       if (type.isTypeVariable) {
         return node;
       }
       if (!type.treatAsRaw) {
@@ skipping 149 matching lines @@
     }
 
     HInstruction receiver = node.getDartReceiver(closedWorld);
     FieldElement field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null || !field.isAssignable) return node;
     // Use `node.inputs.last` in case the call follows the interceptor calling
     // convention, but is not a call on an interceptor.
     HInstruction value = node.inputs.last;
     if (compiler.options.enableTypeAssertions) {
-      DartType type = field.type;
+      ResolutionDartType type = field.type;
       if (!type.treatAsRaw ||
           type.isTypeVariable ||
           type.unaliased.isFunctionType) {
         // We cannot generate the correct type representation here, so don't
         // inline this access.
         // TODO(sra): If the input is such that we don't need a type check, we
         // can skip the test an generate the HFieldSet.
         return node;
       }
       HInstruction other = value.convertType(
@@ skipping 195 matching lines @@
       return new HTypeInfoReadRaw(source, closedWorld.commonMasks.dynamicType);
     }
 
     // TODO(sra): Consider fusing type expression trees with no type variables,
     // as these could be represented like constants.
 
     return tryCopyInfo() ?? node;
   }
 
   HInstruction visitTypeInfoReadVariable(HTypeInfoReadVariable node) {
-    TypeVariableType variable = node.variable;
+    ResolutionTypeVariableType variable = node.variable;
     HInstruction object = node.object;
 
-    HInstruction finishGroundType(InterfaceType groundType) {
-      InterfaceType typeAtVariable =
+    HInstruction finishGroundType(ResolutionInterfaceType groundType) {
+      ResolutionInterfaceType typeAtVariable =
           groundType.asInstanceOf(variable.element.enclosingClass);
       if (typeAtVariable != null) {
         int index = variable.element.index;
-        DartType typeArgument = typeAtVariable.typeArguments[index];
+        ResolutionDartType typeArgument = typeAtVariable.typeArguments[index];
         HInstruction replacement = new HTypeInfoExpression(
             TypeInfoExpressionKind.COMPLETE,
             typeArgument,
             const <HInstruction>[],
             closedWorld.commonMasks.dynamicType);
         return replacement;
       }
       return node;
     }
 
     /// Read the type variable from an allocation of type [createdClass], where
     /// [selectTypeArgumentFromObjectCreation] extracts the type argument from
     /// the allocation for factory constructor call.
     HInstruction finishSubstituted(ClassElement createdClass,
         HInstruction selectTypeArgumentFromObjectCreation(int index)) {
-      HInstruction instructionForTypeVariable(TypeVariableType tv) {
+      HInstruction instructionForTypeVariable(ResolutionTypeVariableType tv) {
         return selectTypeArgumentFromObjectCreation(
             createdClass.thisType.typeArguments.indexOf(tv));
       }
 
-      DartType type = createdClass.thisType
+      ResolutionDartType type = createdClass.thisType
           .asInstanceOf(variable.element.enclosingClass)
           .typeArguments[variable.element.index];
-      if (type is TypeVariableType) {
+      if (type is ResolutionTypeVariableType) {
         return instructionForTypeVariable(type);
       }
       List<HInstruction> arguments = <HInstruction>[];
       type.forEachTypeVariable((v) {
         arguments.add(instructionForTypeVariable(v));
       });
       HInstruction replacement = new HTypeInfoExpression(
           TypeInfoExpressionKind.COMPLETE,
           type,
           arguments,
@@ skipping 888 matching lines @@
     if (dominatedUsers.isEmpty) return;
 
     HTypeKnown newInput = new HTypeKnown.pinned(convertedType, input);
     dominator.addBefore(dominator.first, newInput);
     dominatedUsers.forEach((HInstruction user) {
       user.changeUse(input, newInput);
     });
   }
 
   void visitIs(HIs instruction) {
-    DartType type = instruction.typeExpression;
+    ResolutionDartType type = instruction.typeExpression;
     if (!instruction.isRawCheck) {
       return;
     } else if (type.isTypedef) {
       return;
     }
-    InterfaceType interfaceType = type;
+    ResolutionInterfaceType interfaceType = type;
     ClassEntity cls = interfaceType.element;
 
     List<HBasicBlock> trueTargets = <HBasicBlock>[];
     List<HBasicBlock> falseTargets = <HBasicBlock>[];
 
     collectTargets(instruction, trueTargets, falseTargets);
 
     if (trueTargets.isEmpty && falseTargets.isEmpty) return;
 
     TypeMask convertedType = new TypeMask.nonNullSubtype(cls, closedWorld);
@@ skipping 596 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }