Rewrite ImplicitConstructorBuilder to use only element model.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 4855 matching lines @@
  * Instances of the class `ImplicitConstructorBuilder` are used to build
  * implicit constructors for mixin applications, and to check for errors
  * related to super constructor calls in class declarations with mixins.
  *
  * The visitor methods don't directly build the implicit constructors or check
  * for errors, since they don't in general visit the classes in the proper
  * order to do so correctly.  Instead, they pass closures to
  * ImplicitConstructorBuilderCallback to inform it of the computations to be
  * done and their ordering dependencies.
  */
-class ImplicitConstructorBuilder extends ScopedVisitor {
+class ImplicitConstructorBuilder extends RecursiveElementVisitor {

[Brian Wilkerson, 2015/03/19 17:57:31]

This doesn't need to be a RecursiveElementVisitor because it explicitly does all
of the child visiting itself.

+  final AnalysisErrorListener errorListener;
+
   /**
    * Callback to receive the computations to be performed.
    */
   final ImplicitConstructorBuilderCallback _callback;
 
   /**
-   * Initialize a newly created visitor to build implicit constructors for file
-   * [source], in library [libraryElement], which has scope [libraryScope]. Use
-   * [typeProvider] to access types from the core library.
+   * Initialize a newly created visitor to build implicit constructors.
    *
    * The visit methods will pass closures to [_callback] to indicate what
    * computation needs to be performed, and its dependency order.
    */
-  ImplicitConstructorBuilder(Source source, LibraryElement libraryElement,
-      LibraryScope libraryScope, TypeProvider typeProvider, this._callback)
-      : super.con3(libraryElement, source, typeProvider, libraryScope,
-          libraryScope.errorListener);
+  ImplicitConstructorBuilder(this.errorListener, this._callback);
 
   @override
-  Object visitClassDeclaration(ClassDeclaration node) {
-    ClassElementImpl classElement = node.element;
+  void visitClassElement(ClassElementImpl classElement) {
     classElement.mixinErrorsReported = false;
-    if (node.extendsClause != null && node.withClause != null) {
+    if (classElement.isTypedef) {
+      _visitClassTypeAlias(classElement);
+    } else {
+      _visitClassDeclaration(classElement);
+    }
+  }
+
+  @override
+  void visitCompilationUnitElement(CompilationUnitElement element) {
+    for (ClassElement classElement in element.types) {
+      classElement.accept(this);
+    }
+  }
+
+  void _visitClassDeclaration(ClassElementImpl classElement) {
+    DartType superType = classElement.supertype;
+    if (superType != null && classElement.mixins.isNotEmpty) {
       // We don't need to build any implicitly constructors for the mixin
       // application (since there isn't an explicit element for it), but we
       // need to verify that they _could_ be built.
-      InterfaceType superclassType = null;
-      TypeName superclassName = node.extendsClause.superclass;
-      DartType type = superclassName.type;
-      if (type is InterfaceType) {
-        superclassType = type;
-      } else {
-        superclassType = typeProvider.objectType;
+      if (superType is! InterfaceType) {
+        TypeProvider typeProvider = classElement.context.typeProvider;
+        superType = typeProvider.objectType;
       }
-      ClassElement superclassElement = classElement.supertype.element;
-      if (superclassElement != null) {
-        _callback(classElement, superclassElement, () {
+      ClassElement superElement = superType.element;
+      if (superElement != null) {
+        _callback(classElement, superElement, () {
           bool constructorFound = false;
           void callback(ConstructorElement explicitConstructor,
               List<DartType> parameterTypes, List<DartType> argumentTypes) {
             constructorFound = true;
           }
-          if (_findForwardedConstructors(
-                  classElement, superclassName, superclassType, callback) &&
+          if (_findForwardedConstructors(classElement, superType, callback) &&
               !constructorFound) {
-            reportErrorForNode(CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-                node.withClause, [superclassType.element.name]);
+            SourceRange withRange = classElement.withClauseRange;
+            errorListener.onError(new AnalysisError.con2(classElement.source,
+                withRange.offset, withRange.length,
+                CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
+                [superElement.name]));
             classElement.mixinErrorsReported = true;
           }
         });
       }
     }
-    return null;
   }
 
-  @override
-  Object visitClassTypeAlias(ClassTypeAlias node) {
-    super.visitClassTypeAlias(node);
-    InterfaceType superclassType = null;
-    TypeName superclassName = node.superclass;
-    DartType type = superclassName.type;
-    if (type is InterfaceType) {
-      superclassType = type;
-    } else {
-      superclassType = typeProvider.objectType;
+  void _visitClassTypeAlias(ClassElementImpl classElement) {
+    InterfaceType superType = classElement.supertype;
+    if (superType is InterfaceType) {
+      ClassElement superElement = superType.element;
+      _callback(classElement, superElement, () {
+        List<ConstructorElement> implicitConstructors =
+            new List<ConstructorElement>();
+        void callback(ConstructorElement explicitConstructor,
+            List<DartType> parameterTypes, List<DartType> argumentTypes) {
+          implicitConstructors.add(_createImplicitContructor(classElement.type,
+              explicitConstructor, parameterTypes, argumentTypes));
+        }
+        if (_findForwardedConstructors(classElement, superType, callback)) {
+          if (implicitConstructors.isEmpty) {
+            errorListener.onError(new AnalysisError.con2(classElement.source,
+                classElement.nameOffset, classElement.name.length,
+                CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
+                [superElement.name]));
+          } else {
+            classElement.constructors = implicitConstructors;
+          }
+        }
+      });
     }
-    ClassElementImpl classElement = node.element as ClassElementImpl;
-    if (classElement != null) {
-      ClassElement superclassElement = superclassType.element;
-      if (superclassElement != null) {
-        _callback(classElement, superclassElement, () {
-          List<ConstructorElement> implicitConstructors =
-              new List<ConstructorElement>();
-          void callback(ConstructorElement explicitConstructor,
-              List<DartType> parameterTypes, List<DartType> argumentTypes) {
-            implicitConstructors.add(_createImplicitContructor(
-                classElement.type, explicitConstructor, parameterTypes,
-                argumentTypes));
-          }
-          if (_findForwardedConstructors(
-              classElement, superclassName, superclassType, callback)) {
-            if (implicitConstructors.isEmpty) {
-              reportErrorForNode(CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-                  node, [superclassElement.name]);
-            } else {
-              classElement.constructors = implicitConstructors;
-            }
-          }
-        });
-      }
-    }
-    return null;
   }
 
-  @override
-  Object visitEnumDeclaration(EnumDeclaration node) => null;
-
-  @override
-  Object visitFunctionDeclaration(FunctionDeclaration node) => null;
-
-  @override
-  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) =>
-      null;
-
   /**
    * Create an implicit constructor that is copied from the given constructor, but that is in the
    * given class.
    *
    * @param classType the class in which the implicit constructor is defined
    * @param explicitConstructor the constructor on which the implicit constructor is modeled
    * @param parameterTypes the types to be replaced when creating parameters
    * @param argumentTypes the types with which the parameters are to be replaced
    * @return the implicit constructor that was created
    */
-  ConstructorElement _createImplicitContructor(InterfaceType classType,
+  static ConstructorElement _createImplicitContructor(InterfaceType classType,

[Brian Wilkerson, 2015/03/19 17:57:31]

I don't like making methods like this 'static'. I understand that they don't
reference any instance state, but I don't think it makes sense for them to be
used except by an instance of this class, and I think 'static' conveys the wrong
impression. (I would only use 'static' for stand-alone utility methods being
provided by the class.) Your call, though.

       ConstructorElement explicitConstructor, List<DartType> parameterTypes,
       List<DartType> argumentTypes) {
     ConstructorElementImpl implicitConstructor =
         new ConstructorElementImpl(explicitConstructor.name, -1);
     implicitConstructor.synthetic = true;
     implicitConstructor.redirectedConstructor = explicitConstructor;
     implicitConstructor.const2 = explicitConstructor.isConst;
     implicitConstructor.returnType = classType;
     List<ParameterElement> explicitParameters = explicitConstructor.parameters;
     int count = explicitParameters.length;
@@ skipping 14 matching lines @@
       }
       implicitConstructor.parameters = implicitParameters;
     }
     FunctionTypeImpl type = new FunctionTypeImpl.con1(implicitConstructor);
     type.typeArguments = classType.typeArguments;
     implicitConstructor.type = type;
     return implicitConstructor;
   }
 
   /**
-   * Find all the constructors that should be forwarded from the superclass
-   * named [superclassName], having type [superclassType], to the class or
-   * mixin application [classElement], and pass information about them to
-   * [callback].
+   * Find all the constructors that should be forwarded from the given
+   * [superclassType], to the class or mixin application [classElement],
+   * and pass information about them to [callback].
    *
    * Return true if some constructors were considered.  (A false return value
    * can only happen if the supeclass is a built-in type, in which case it
    * can't be used as a mixin anyway).
    */
-  bool _findForwardedConstructors(ClassElementImpl classElement,
-      TypeName superclassName, InterfaceType superclassType, void callback(
+  static bool _findForwardedConstructors(ClassElementImpl classElement,
+      InterfaceType superclassType, void callback(
           ConstructorElement explicitConstructor, List<DartType> parameterTypes,
           List<DartType> argumentTypes)) {
     ClassElement superclassElement = superclassType.element;
     List<ConstructorElement> constructors = superclassElement.constructors;
     int count = constructors.length;
     if (count == 0) {
       return false;
     }
     List<DartType> parameterTypes =
         TypeParameterTypeImpl.getTypes(superclassType.typeParameters);
     List<DartType> argumentTypes =
-        _getArgumentTypes(superclassName.typeArguments, parameterTypes);
+        _getArgumentTypes(superclassType, parameterTypes);
     for (int i = 0; i < count; i++) {
       ConstructorElement explicitConstructor = constructors[i];
       if (!explicitConstructor.isFactory &&
           classElement.isSuperConstructorAccessible(explicitConstructor)) {
         callback(explicitConstructor, parameterTypes, argumentTypes);
       }
     }
     return true;
   }
 
   /**
-   * Return an array of argument types that corresponds to the array of parameter types and that are
-   * derived from the given list of type arguments.
-   *
-   * @param typeArguments the type arguments from which the types will be taken
-   * @param parameterTypes the parameter types that must be matched by the type arguments
-   * @return the argument types that correspond to the parameter types
+   * Return a list of argument types that corresponds to the [parameterTypes]
+   * and that are derived from the type arguments of the given [supertype].
    */
-  List<DartType> _getArgumentTypes(
-      TypeArgumentList typeArguments, List<DartType> parameterTypes) {
+  static List<DartType> _getArgumentTypes(
+      InterfaceType supertype, List<DartType> parameterTypes) {
     DynamicTypeImpl dynamic = DynamicTypeImpl.instance;
     int parameterCount = parameterTypes.length;
     List<DartType> types = new List<DartType>(parameterCount);
-    if (typeArguments == null) {
-      for (int i = 0; i < parameterCount; i++) {
-        types[i] = dynamic;
-      }
+    if (supertype == null) {
+      types = new List<DartType>.filled(parameterCount, dynamic);
     } else {
-      NodeList<TypeName> arguments = typeArguments.arguments;
-      int argumentCount = math.min(arguments.length, parameterCount);
+      List<DartType> typeArguments = supertype.typeArguments;
+      int argumentCount = math.min(typeArguments.length, parameterCount);
       for (int i = 0; i < argumentCount; i++) {
-        types[i] = arguments[i].type;
+        types[i] = typeArguments[i];
       }
       for (int i = argumentCount; i < parameterCount; i++) {
         types[i] = dynamic;
       }
     }
     return types;
   }
 }
 
 /**
  * An instance of this class is capable of running ImplicitConstructorBuilder
  * over all classes in a library cycle.
  */
 class ImplicitConstructorComputer {
   /**
-   * The object used to access the types from the core library.
-   */
-  final TypeProvider typeProvider;
-
-  /**
    * Directed graph of dependencies between classes that need to have their
    * implicit constructors computed.  Each edge in the graph points from a
    * derived class to its superclass.  Implicit constructors will be computed
    * for the superclass before they are compute for the derived class.
    */
   DirectedGraph<ClassElement> _dependencies = new DirectedGraph<ClassElement>();
 
   /**
    * Map from ClassElement to the function which will compute the class's
    * implicit constructors.
    */
   Map<ClassElement, VoidFunction> _computations =
       new HashMap<ClassElement, VoidFunction>();
 
   /**
-   * Create an ImplicitConstructorComputer which will use [typeProvider] to
-   * access types from the core library.
+   * Add the given [libraryElement] to the list of libraries which need to have
+   * implicit constructors built for them.
    */
-  ImplicitConstructorComputer(this.typeProvider);
-
-  /**
-   * Add the given [unit] to the list of units which need to have implicit
-   * constructors built for them.  [source] is the source file corresponding to
-   * the compilation unit, [libraryElement] is the library element containing
-   * that source, and [libraryScope] is the scope for the library element.
-   */
-  void add(CompilationUnit unit, Source source, LibraryElement libraryElement,
-      LibraryScope libraryScope) {
-    unit.accept(new ImplicitConstructorBuilder(
-        source, libraryElement, libraryScope, typeProvider, _defer));
+  void add(AnalysisErrorListener errorListener, LibraryElement libraryElement) {
+    libraryElement
+        .accept(new ImplicitConstructorBuilder(errorListener, _defer));
   }
 
   /**
    * Compute the implicit constructors for all compilation units that have been
    * passed to [add].
    */
   void compute() {
     List<List<ClassElement>> topologicalSort =
         _dependencies.computeTopologicalSort();
     for (List<ClassElement> classesInCycle in topologicalSort) {
@@ skipping 2906 matching lines @@
   }
 
   /**
    * Finish steps that the [buildTypeHierarchies] could not perform, see
    * [ImplicitConstructorBuilder].
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildImplicitConstructors() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
-      ImplicitConstructorComputer computer =
-          new ImplicitConstructorComputer(_typeProvider);
+      ImplicitConstructorComputer computer = new ImplicitConstructorComputer();
       for (Library library in _librariesInCycles) {
-        for (Source source in library.compilationUnitSources) {
-          computer.add(library.getAST(source), source, library.libraryElement,
-              library.libraryScope);
-        }
+        computer.add(_errorListener, library.libraryElement);
       }
       computer.compute();
     });
   }
 
   /**
    * Resolve the types referenced by function type aliases across all of the function type aliases
    * defined in the current cycle.
    *
    * @throws AnalysisException if any of the function type aliases could not be resolved
@@ skipping 678 matching lines @@
   }
 
   /**
    * Finish steps that the [buildTypeHierarchies] could not perform, see
    * [ImplicitConstructorBuilder].
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildImplicitConstructors() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
-      ImplicitConstructorComputer computer =
-          new ImplicitConstructorComputer(_typeProvider);
+      ImplicitConstructorComputer computer = new ImplicitConstructorComputer();
       for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit
-            in library.resolvableCompilationUnits) {
-          Source source = unit.source;
-          CompilationUnit ast = unit.compilationUnit;
-          computer.add(
-              ast, source, library.libraryElement, library.libraryScope);
-        }
+        computer.add(_errorListener, library.libraryElement);
       }
       computer.compute();
     });
   }
 
   HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
     HashMap<Source, ResolvableLibrary> libraryMap =
         new HashMap<Source, ResolvableLibrary>();
     int libraryCount = _librariesInCycle.length;
     for (int i = 0; i < libraryCount; i++) {
@@ skipping 5791 matching lines @@
    */
   void _resolve(ClassElementImpl classElement, WithClause withClause,
       ImplementsClause implementsClause) {
     if (withClause != null) {
       List<InterfaceType> mixinTypes = _resolveTypes(withClause.mixinTypes,
           CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
           CompileTimeErrorCode.MIXIN_OF_ENUM,
           CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
       if (classElement != null) {
         classElement.mixins = mixinTypes;
+        classElement.withClauseRange =
+            new SourceRange(withClause.offset, withClause.length);
       }
     }
     if (implementsClause != null) {
       NodeList<TypeName> interfaces = implementsClause.interfaces;
       List<InterfaceType> interfaceTypes = _resolveTypes(interfaces,
           CompileTimeErrorCode.IMPLEMENTS_NON_CLASS,
           CompileTimeErrorCode.IMPLEMENTS_ENUM,
           CompileTimeErrorCode.IMPLEMENTS_DYNAMIC);
       if (classElement != null) {
         classElement.interfaces = interfaceTypes;
@@ skipping 224 matching lines @@
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
 
   @override
-  Object visitMethodDeclaration(MethodDeclaration node) {
-    ExecutableElement outerFunction = _enclosingFunction;
-    try {
-      _enclosingFunction = node.element;
-      return super.visitMethodDeclaration(node);
-    } finally {
-      _enclosingFunction = outerFunction;
-    }
-  }
-
-  @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       ExecutableElement outerFunction = _enclosingFunction;
       try {
         _enclosingFunction = node.element;
         return super.visitFunctionExpression(node);
       } finally {
         _enclosingFunction = outerFunction;
       }
     } else {
       return super.visitFunctionExpression(node);
     }
   }
 
   @override
   Object visitImportDirective(ImportDirective node) => null;
 
   @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      return super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+  }
+
+  @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     // Ignore if already resolved - declaration or type.
     if (node.staticElement != null) {
       return null;
     }
     // Ignore if qualified.
     AstNode parent = node.parent;
     if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
       return null;
     }
@@ skipping 520 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }