Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart

 // Copyright (c) 2015, 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 dart2js.semantics_visitor;
 
 /// Interface for bulk handling of a [Node] in a semantic visitor.
 abstract class BulkHandle<R, A> {
   /// Handle [node] either regardless of semantics or to report that [node] is
   /// unhandled. [message] contains a message template for the latter case:
   /// Replace '#' in [message] by `node.toString()` to create a message for the
   /// error.
   R bulkHandleNode(Node node, String message, A arg);
 }
 
 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
 abstract class ErrorBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
   // TODO(johnniwinther): Ensure that all error methods have an
   // [ErroneousElement].
   R bulkHandleError(Node node, ErroneousElement error, A arg) {
     return bulkHandleNode(node, "Error expression `#` unhandled.", arg);
   }
 
   @override
-  R errorNonConstantConstructorInvoke(NewExpression node, Element element,
-      DartType type, NodeList arguments, CallStructure callStructure, A arg) {
+  R errorNonConstantConstructorInvoke(
+      NewExpression node,
+      Element element,
+      ResolutionDartType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
     return bulkHandleError(node, null, arg);
   }
 
   @override
   R errorUndefinedUnaryExpression(
       Send node, Operator operator, Node expression, A arg) {
     return bulkHandleError(node, null, arg);
   }
 
   @override
@@ skipping 1865 matching lines @@
 }
 
 /// Mixin that implements all purely structural visitor methods in
 /// [SemanticSendVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all purely structural
 /// visitor methods.
 abstract class BaseBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
   @override
-  R visitAs(Send node, Node expression, DartType type, A arg) {
+  R visitAs(Send node, Node expression, ResolutionDartType type, A arg) {
     return bulkHandleNode(node, 'As cast `#` unhandled.', arg);
   }
 
   @override
-  R visitIs(Send node, Node expression, DartType type, A arg) {
+  R visitIs(Send node, Node expression, ResolutionDartType type, A arg) {
     return bulkHandleNode(node, 'Is test `#` unhandled.', arg);
   }
 
   @override
-  R visitIsNot(Send node, Node expression, DartType type, A arg) {
+  R visitIsNot(Send node, Node expression, ResolutionDartType type, A arg) {
     return bulkHandleNode(node, 'Is not test `#` unhandled.', arg);
   }
 
   @override
   R visitIfNull(Send node, Node left, Node right, A arg) {
     return bulkHandleNode(node, 'If-null (Lazy ?? `#`) unhandled.', arg);
   }
 
   @override
   R visitLogicalAnd(Send node, Node left, Node right, A arg) {
@@ skipping 252 matching lines @@
 abstract class NewBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
   R bulkHandleNew(NewExpression node, A arg) {
     return bulkHandleNode(node, "Constructor invocation `#` unhandled.", arg);
   }
 
   @override
   R visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement element,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitConstConstructorInvoke(
       NewExpression node, ConstructedConstantExpression constant, A arg) {
     return bulkHandleNew(node, arg);
@@ skipping 14 matching lines @@
   @override
   R visitStringFromEnvironmentConstructorInvoke(NewExpression node,
       StringFromEnvironmentConstantExpression constant, A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitConstructorIncompatibleInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
+      ResolutionInterfaceType effectiveTargetType,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitUnresolvedClassConstructorInvoke(NewExpression node, Element element,
-      DartType type, NodeList arguments, Selector selector, A arg) {
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitUnresolvedConstructorInvoke(NewExpression node, Element constructor,
-      DartType type, NodeList arguments, Selector selector, A arg) {
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg) {
     return bulkHandleNew(node, arg);
   }
 
   @override
   R visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 }
 
 /// Visitor that implements [SemanticSendVisitor] by the use of `BulkX` mixins.
 ///
 /// This class is useful in itself, but shows how to use the `BulkX` mixins and
@@ skipping 113 matching lines @@
       Node body,
       A arg) {
     return bulkHandleConstructorDeclaration(node, arg);
   }
 
   @override
   R visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
-      InterfaceType redirectionType,
+      ResolutionInterfaceType redirectionType,
       ConstructorElement redirectionTarget,
       A arg) {
     return bulkHandleConstructorDeclaration(node, arg);
   }
 
   @override
   R visitRedirectingGenerativeConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
@@ skipping 34 matching lines @@
   @override
   R visitFieldInitializer(
       SendSet node, FieldElement field, Node initializer, A arg) {
     return bulkHandleInitializer(node, arg);
   }
 
   @override
   R visitSuperConstructorInvoke(
       Send node,
       ConstructorElement superConstructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleInitializer(node, arg);
   }
 
   @override
-  R visitImplicitSuperConstructorInvoke(FunctionExpression node,
-      ConstructorElement superConstructor, InterfaceType type, A arg) {
+  R visitImplicitSuperConstructorInvoke(
+      FunctionExpression node,
+      ConstructorElement superConstructor,
+      ResolutionInterfaceType type,
+      A arg) {
     return bulkHandleInitializer(node, arg);
   }
 
   @override
   R visitThisConstructorInvoke(Send node, ConstructorElement thisConstructor,
       NodeList arguments, CallStructure callStructure, A arg) {
     return bulkHandleInitializer(node, arg);
   }
 }
 
@@ skipping 500 matching lines @@
   }
 
   @override
   R visitUnresolvedSuperInvoke(Send node, Element function, NodeList arguments,
       Selector selector, A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitAs(Send node, Node expression, DartType type, A arg) {
+  R visitAs(Send node, Node expression, ResolutionDartType type, A arg) {
     apply(expression, arg);
     return null;
   }
 
   @override
   R visitBinary(
       Send node, Node left, BinaryOperator operator, Node right, A arg) {
     apply(left, arg);
     apply(right, arg);
     return null;
@@ skipping 195 matching lines @@
 
   @override
   R visitIndexSet(SendSet node, Node receiver, Node index, Node rhs, A arg) {
     apply(receiver, arg);
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitIs(Send node, Node expression, DartType type, A arg) {
+  R visitIs(Send node, Node expression, ResolutionDartType type, A arg) {
     apply(expression, arg);
     return null;
   }
 
   @override
-  R visitIsNot(Send node, Node expression, DartType type, A arg) {
+  R visitIsNot(Send node, Node expression, ResolutionDartType type, A arg) {
     apply(expression, arg);
     return null;
   }
 
   @override
   R visitLocalFunctionGet(Send node, LocalFunctionElement function, A arg) {
     return null;
   }
 
   @override
@@ skipping 1165 matching lines @@
   @override
   R visitStringFromEnvironmentConstructorInvoke(NewExpression node,
       StringFromEnvironmentConstantExpression constant, A arg) {
     return null;
   }
 
   @override
   R visitConstructorIncompatibleInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitUnresolvedClassConstructorInvoke(
       NewExpression node,
       Element constructor,
-      DartType type,
+      ResolutionDartType type,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitUnresolvedConstructorInvoke(NewExpression node, Element constructor,
-      DartType type, NodeList arguments, Selector selector, A arg) {
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
+      ResolutionInterfaceType effectiveTargetType,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement element,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R errorNonConstantConstructorInvoke(NewExpression node, Element element,
-      DartType type, NodeList arguments, CallStructure callStructure, A arg) {
+  R errorNonConstantConstructorInvoke(
+      NewExpression node,
+      Element element,
+      ResolutionDartType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitUnresolvedStaticGetterCompound(Send node, Element element,
       MethodElement setter, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
@@ skipping 383 matching lines @@
     applyParameters(parameters, arg);
     apply(body, arg);
     return null;
   }
 
   @override
   R visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
-      InterfaceType redirectionType,
+      ResolutionInterfaceType redirectionType,
       ConstructorElement redirectionTarget,
       A arg) {
     applyParameters(parameters, arg);
     return null;
   }
 
   @override
   R visitRedirectingGenerativeConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
@@ skipping 10 matching lines @@
       MethodElement function, NodeList parameters, Node body, A arg) {
     applyParameters(parameters, arg);
     apply(body, arg);
     return null;
   }
 
   @override
   R visitSuperConstructorInvoke(
       Send node,
       ConstructorElement superConstructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitImplicitSuperConstructorInvoke(FunctionExpression node,
-      ConstructorElement superConstructor, InterfaceType type, A arg) {
+  R visitImplicitSuperConstructorInvoke(
+      FunctionExpression node,
+      ConstructorElement superConstructor,
+      ResolutionInterfaceType type,
+      A arg) {
     return null;
   }
 
   @override
   R visitThisConstructorInvoke(Send node, ConstructorElement thisConstructor,
       NodeList arguments, CallStructure callStructure, A arg) {
     apply(arguments, arg);
     return null;
   }
 
@@ skipping 3221 matching lines @@
   }
 }
 
 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
 /// delegating calls to the `handleConstructorInvoke` method.
 ///
 /// This mixin is useful for the cases where all constructor invocations are
 /// handled uniformly.
 abstract class BaseImplementationOfNewMixin<R, A>
     implements SemanticSendVisitor<R, A> {
-  R handleConstructorInvoke(NewExpression node, ConstructorElement constructor,
-      DartType type, NodeList arguments, CallStructure callStructure, A arg);
+  R handleConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      ResolutionDartType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg);
 
   R visitGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 
   @override
   R visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 
   @override
   R visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 
   @override
   R visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
+      ResolutionInterfaceType effectiveTargetType,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 
   @override
   R visitUnresolvedConstructorInvoke(NewExpression node, Element constructor,
-      DartType type, NodeList arguments, Selector selector, A arg) {
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, selector.callStructure, arg);
   }
 
   @override
   R visitUnresolvedClassConstructorInvoke(NewExpression node, Element element,
-      DartType type, NodeList arguments, Selector selector, A arg) {
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg) {
     return handleConstructorInvoke(
         node, element, type, arguments, selector.callStructure, arg);
   }
 
   @override
   R visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 
   @override
   R visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 }