Transition analyzer and analysis_server to new astFactory; remove old AST factory methods.

pkg/analyzer/lib/src/generated/type_system.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 analyzer.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
@@ skipping 153 matching lines @@
 
   StrongTypeSystemImpl(
       {this.implicitCasts: true,
       this.nonnullableTypes: AnalysisOptionsImpl.NONNULLABLE_TYPES});
 
   bool anyParameterType(FunctionType ft, bool predicate(DartType t)) {
     return ft.parameters.any((p) => predicate(p.type));
   }
 
   @override
-  DartType tryPromoteToType(DartType to, DartType from) {
-    // Allow promoting to a subtype, for example:
-    //
-    //     f(Base b) {
-    //       if (b is SubTypeOfBase) {
-    //         // promote `b` to SubTypeOfBase for this block
-    //       }
-    //     }
-    //
-    // This allows the variable to be used wherever the supertype (here `Base`)
-    // is expected, while gaining a more precise type.
-    if (isSubtypeOf(to, from)) {
-      return to;
-    }
-    // For a type parameter `T extends U`, allow promoting the upper bound
-    // `U` to `S` where `S <: U`, yielding a type parameter `T extends S`.
-    if (from is TypeParameterType) {
-      if (isSubtypeOf(to, from.resolveToBound(DynamicTypeImpl.instance))) {
-        return new TypeParameterMember(from.element, null, to).type;
-      }
-    }
-
-    return null;
-  }
-
-  @override
   FunctionType functionTypeToConcreteType(
       TypeProvider typeProvider, FunctionType t) {
     // TODO(jmesserly): should we use a real "fuzzyArrow" bit on the function
     // type? That would allow us to implement this in the subtype relation.
     // TODO(jmesserly): we'll need to factor this differently if we want to
     // move CodeChecker's functionality into existing analyzer. Likely we can
     // let the Expression have a strict arrow, then in places were we do
     // inference, convert back to a fuzzy arrow.
 
     if (!t.parameters.any((p) => p.type.isDynamic)) {
@@ skipping 393 matching lines @@
           return typeProvider.doubleType;
         }
       }
       return currentType;
     }
     return super.refineBinaryExpressionType(
         typeProvider, leftType, operator, rightType, currentType);
   }
 
   @override
+  DartType tryPromoteToType(DartType to, DartType from) {

[Brian Wilkerson, 2016/11/30 20:05:31]

This appears to just be sorting changes. Let me know if that's not true.

[Paul Berry, 2016/11/30 20:21:57]

Whoops, you are correct.  Reverted this file to avoid confusion.

+    // Allow promoting to a subtype, for example:
+    //
+    //     f(Base b) {
+    //       if (b is SubTypeOfBase) {
+    //         // promote `b` to SubTypeOfBase for this block
+    //       }
+    //     }
+    //
+    // This allows the variable to be used wherever the supertype (here `Base`)
+    // is expected, while gaining a more precise type.
+    if (isSubtypeOf(to, from)) {
+      return to;
+    }
+    // For a type parameter `T extends U`, allow promoting the upper bound
+    // `U` to `S` where `S <: U`, yielding a type parameter `T extends S`.
+    if (from is TypeParameterType) {
+      if (isSubtypeOf(to, from.resolveToBound(DynamicTypeImpl.instance))) {
+        return new TypeParameterMember(from.element, null, to).type;
+      }
+    }
+
+    return null;
+  }
+
+  @override
   DartType typeToConcreteType(TypeProvider typeProvider, DartType t) {
     if (t is FunctionType) {
       return functionTypeToConcreteType(typeProvider, t);
     }
     return t;
   }
 
   /**
    * Compute the greatest lower bound of function types [f] and [g].
    *
@@ skipping 416 matching lines @@
 
 /**
  * The interface `TypeSystem` defines the behavior of an object representing
  * the type system.  This provides a common location to put methods that act on
  * types but may need access to more global data structures, and it paves the
  * way for a possible future where we may wish to make the type system
  * pluggable.
  */
 abstract class TypeSystem {
   /**
-   * Tries to promote from the first type from the second type, and returns the
-   * promoted type if it succeeds, otherwise null.
-   *
-   * In the Dart 1 type system, it is not possible to promote from or to
-   * `dynamic`, and we must be promoting to a more specific type, see
-   * [isMoreSpecificThan]. Also it will always return the promote [to] type or
-   * null.
-   *
-   * In strong mode, this can potentially return a different type, see
-   * the override in [StrongTypeSystemImpl].
-   */
-  DartType tryPromoteToType(DartType to, DartType from);
-
-  /**
    * Make a function type concrete.
    *
    * Normally we treat dynamically typed parameters as bottom for function
    * types. This allows type tests such as `if (f is SingleArgFunction)`.
    * It also requires a dynamic check on the parameter type to call these
    * functions.
    *
    * When we convert to a strict arrow, dynamically typed parameters become
    * top. This is safe to do for known functions, like top-level or local
    * functions and static methods. Those functions must already be essentially
@@ skipping 192 matching lines @@
         if (rightType == intType) {
           return intType;
         }
       }
     }
     // default
     return currentType;
   }
 
   /**
+   * Tries to promote from the first type from the second type, and returns the
+   * promoted type if it succeeds, otherwise null.
+   *
+   * In the Dart 1 type system, it is not possible to promote from or to
+   * `dynamic`, and we must be promoting to a more specific type, see
+   * [isMoreSpecificThan]. Also it will always return the promote [to] type or
+   * null.
+   *
+   * In strong mode, this can potentially return a different type, see
+   * the override in [StrongTypeSystemImpl].
+   */
+  DartType tryPromoteToType(DartType to, DartType from);
+
+  /**
    * Given a [DartType] type, return the [TypeParameterElement]s corresponding
    * to its formal type parameters (if any).
    *
    * @param type the type whose type arguments are to be returned
    * @return the type arguments associated with the given type
    */
   List<TypeParameterElement> typeFormalsAsElements(DartType type) {
     if (type is FunctionType) {
       return type.typeFormals;
     } else if (type is InterfaceType) {
@@ skipping 131 matching lines @@
   }
 }
 
 /**
  * Implementation of [TypeSystem] using the rules in the Dart specification.
  */
 class TypeSystemImpl extends TypeSystem {
   TypeSystemImpl();
 
   @override
-  DartType tryPromoteToType(DartType to, DartType from) {
-    // Declared type should not be "dynamic".
-    // Promoted type should not be "dynamic".
-    // Promoted type should be more specific than declared.
-    if (!from.isDynamic && !to.isDynamic && to.isMoreSpecificThan(from)) {
-      return to;
-    } else {
-      return null;
-    }
-  }
-
-  @override
   FunctionType functionTypeToConcreteType(
           TypeProvider typeProvider, FunctionType t) =>
       t;
 
   /**
    * Instantiate a parameterized type using `dynamic` for all generic
    * parameters.  Returns the type unchanged if there are no parameters.
    */
   DartType instantiateToBounds(DartType type) {
     List<DartType> typeFormals = typeFormalsAsTypes(type);
@@ skipping 14 matching lines @@
   @override
   bool isMoreSpecificThan(DartType t1, DartType t2) =>
       t1.isMoreSpecificThan(t2);
 
   @override
   bool isSubtypeOf(DartType leftType, DartType rightType) {
     return leftType.isSubtypeOf(rightType);
   }
 
   @override
+  DartType tryPromoteToType(DartType to, DartType from) {
+    // Declared type should not be "dynamic".
+    // Promoted type should not be "dynamic".
+    // Promoted type should be more specific than declared.
+    if (!from.isDynamic && !to.isDynamic && to.isMoreSpecificThan(from)) {
+      return to;
+    } else {
+      return null;
+    }
+  }
+
+  @override
   DartType typeToConcreteType(TypeProvider typeProvider, DartType t) => t;
 
   @override
   DartType _interfaceLeastUpperBound(
       TypeProvider provider, InterfaceType type1, InterfaceType type2) {
     InterfaceType result =
         InterfaceTypeImpl.computeLeastUpperBound(type1, type2);
     return result ?? provider.dynamicType;
   }
 
@@ skipping 312 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }