Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/semantic_visitor.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.
 
 library dart2js.semantics_visitor;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 1413 matching lines @@
   ///
   R visitLogicalOr(Send node, Node left, Node right, A arg);
 
   /// Is test of [expression] against [type].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => expression is C;
   ///
-  R visitIs(Send node, Node expression, DartType type, A arg);
+  R visitIs(Send node, Node expression, ResolutionDartType type, A arg);
 
   /// Is not test of [expression] against [type].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => expression is! C;
   ///
-  R visitIsNot(Send node, Node expression, DartType type, A arg);
+  R visitIsNot(Send node, Node expression, ResolutionDartType type, A arg);
 
   /// As cast of [expression] to [type].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => expression as C;
   ///
-  R visitAs(Send node, Node expression, DartType type, A arg);
+  R visitAs(Send node, Node expression, ResolutionDartType type, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] of the property on
   /// [receiver] whose getter and setter are defined by [getterSelector] and
   /// [setterSelector], respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver, rhs) => receiver.foo += rhs;
   ///
   R visitDynamicPropertyCompound(Send node, Node receiver, Name name,
@@ skipping 758 matching lines @@
   /// For instance:
   ///
   ///     typedef F();
   ///     m(rhs) => F ??= rhs;
   ///
   R visitTypedefTypeLiteralSetIfNull(
       Send node, ConstantExpression constant, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the type literal for the type
   /// variable [element]. That is, [rhs] is only evaluated and assigned, if
-  /// the value is of the [element] is `null`. The behavior is thus equivalent to
-  /// a type literal access.
+  /// the value is of the [element] is `null`. The behavior is thus equivalent
+  /// to a type literal access.
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m(rhs) => T ??= rhs;
   ///     }
   ///
   R visitTypeVariableTypeLiteralSetIfNull(
       Send node, TypeVariableElement element, Node rhs, A arg);
 
@@ skipping 1617 matching lines @@
   ///     class C<T> {
   ///       C(a, b);
   ///     }
   ///     m() => new C<int>(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   R visitGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of a redirecting generative [constructor] on [type] with
   /// [arguments].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       C(a, b) : this._(b, a);
   ///       C._(b, a);
   ///     }
   ///     m() => new C<int>(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   R visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       factory C(a, b) => new C<T>._(b, a);
   ///       C._(b, a);
   ///     }
   ///     m() => new C<int>(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   R visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments] where
   /// [effectiveTarget] and [effectiveTargetType] are the constructor effective
   /// invoked and its type, respectively.
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       factory C(a, b) = C<int>.a;
   ///       factory C.a(a, b) = C<C<T>>.b;
   ///       C.b(a, b);
   ///     }
   ///     m() => new C<double>(true, 42);
   ///
   /// where [type] is `C<double>`, [effectiveTarget] is `C.b` and
   /// [effectiveTargetType] is `C<C<int>>`.
   ///
   R visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
+      ResolutionInterfaceType effectiveTargetType,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of an unresolved [constructor] on [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       C();
   ///     }
   ///     m() => new C<int>.unresolved(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   // TODO(johnniwinther): Change [type] to [InterfaceType] when is it not
   // `dynamic`.
   R visitUnresolvedConstructorInvoke(NewExpression node, Element constructor,
-      DartType type, NodeList arguments, Selector selector, A arg);
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg);
 
   /// Invocation of a constructor on an unresolved [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
   // TODO(johnniwinther): Change [type] to [MalformedType] when is it not
   // `dynamic`.
   R visitUnresolvedClassConstructorInvoke(NewExpression node, Element element,
-      DartType type, NodeList arguments, Selector selector, A arg);
+      ResolutionDartType type, NodeList arguments, Selector selector, A arg);
 
   /// Constant invocation of a non-constant constructor.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       C(a, b);
   ///     }
   ///     m() => const C(true, 42);
   ///
-  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);
 
   /// Invocation of a constructor on an abstract [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
   R visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement element,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments] where
   /// [effectiveTarget] and [effectiveTargetType] are the constructor effective
   /// invoked and its type, respectively.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       factory C(a, b) = Unresolved;
   ///       factory C.a(a, b) = C.unresolved;
   ///     }
   ///     m1() => new C(true, 42);
   ///     m2() => new C.a(true, 42);
   ///
   R visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of [constructor] on [type] with incompatible [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       C(a);
   ///     }
   ///     m() => C(true, 42);
   ///
   R visitConstructorIncompatibleInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Read access of an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
@@ skipping 559 matching lines @@
   ///      factory C.a() = C<C<T>>.b;
   ///      C.b();
   ///    }
   /// where `C` has the redirection target `C.a` of type `C<int>` and `C.a` has
   /// the redirection target `C.b` of type `C<C<T>>`.
   ///
   R visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
-      InterfaceType redirectionType,
+      ResolutionInterfaceType redirectionType,
       ConstructorElement redirectionTarget,
       A arg);
 
   /// An initializer of [field] with [initializer] as found in constructor
   /// initializers.
   ///
   /// For instance `this.a = 42` in:
   ///
   ///     class C {
   ///       var a;
@@ skipping 23 matching lines @@
   ///     class B {
   ///       B(a);
   ///     }
   ///     class C extends B {
   ///       C() : super(42);
   ///     }
   ///
   R visitSuperConstructorInvoke(
       Send node,
       ConstructorElement superConstructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// An implicit super constructor invocation of [superConstructor] from
   /// generative constructor initializers.
   ///
   /// For instance `super(42)` in:
   ///
   ///     class B {
   ///       B();
   ///     }
   ///     class C extends B {
   ///       C(); // Implicit super call of B().
   ///     }
   ///
   R visitImplicitSuperConstructorInvoke(FunctionExpression node,
-      ConstructorElement superConstructor, InterfaceType type, A arg);
+      ConstructorElement superConstructor, ResolutionInterfaceType type, A arg);
 
   /// An super constructor invocation of an unresolved with [arguments] as
   /// found in generative constructor initializers.
   ///
   /// For instance `super(42)` in:
   ///
   ///     class B {
   ///       B(a);
   ///     }
   ///     class C extends B {
@@ skipping 21 matching lines @@
   ///
   /// For instance `this._(42)` in:
   ///
   ///     class C {
   ///       C() : this._(42);
   ///     }
   ///
   R errorUnresolvedThisConstructorInvoke(
       Send node, Element element, NodeList arguments, Selector selector, A arg);
 }