Minor changes in analyzer to make it easier to extend

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 8291 matching lines @@
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
     PerformanceTag prevTag =
         PerformanceStatistics.resolve.makeCurrent();
     try {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
-          TypeResolverVisitor visitor =
-              new TypeResolverVisitor.con1(library, source, _typeProvider);
+          TypeResolverVisitorFactory typeResolverVisitorFactory =
+              analysisContext.typeResolverVisitorFactory;
+          TypeResolverVisitor visitor = (typeResolverVisitorFactory == null)
+              ? new TypeResolverVisitor.con1(library, source, _typeProvider)
+              : typeResolverVisitorFactory(library, source, _typeProvider);
           library.getAST(source).accept(visitor);
         }
       }
     } finally {
       prevTag.makeCurrent();
     }
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
@@ skipping 261 matching lines @@
    *           the library cannot be analyzed
    */
   void _resolveReferencesAndTypesInLibrary(Library library) {
     PerformanceTag prevTag =
         PerformanceStatistics.resolve.makeCurrent();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         ast.accept(
             new VariableResolverVisitor.con1(library, source, _typeProvider));
-        ResolverVisitor visitor =
-            new ResolverVisitor.con1(library, source, _typeProvider);
+        ResolverVisitorFactory visitorFactory =
+            analysisContext.resolverVisitorFactory;
+        ResolverVisitor visitor = visitorFactory != null
+            ? visitorFactory(library, source, _typeProvider)
+            : new ResolverVisitor.con1(library, source, _typeProvider);
         ast.accept(visitor);
       }
     } finally {
       prevTag.makeCurrent();
     }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
@@ skipping 1758 matching lines @@
   const ResolverErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 
   @override
   ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
 }
 
+typedef ResolverVisitor ResolverVisitorFactory(
+    Library library, Source source, TypeProvider typeProvider);
+
+typedef TypeResolverVisitor TypeResolverVisitorFactory(
+    Library library, Source source, TypeProvider typeProvider);
+
+typedef StaticTypeAnalyzer StaticTypeAnalyzerFactory(ResolverVisitor visitor);
+
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  */
 class ResolverVisitor extends ScopedVisitor {
   /**
    * The manager for the inheritance mappings.
    */
   InheritanceManager _inheritanceManager;
 
@@ skipping 58 matching lines @@
   bool resolveOnlyCommentInFunctionBody = false;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(Library library, Source source,
-      TypeProvider typeProvider)
+      TypeProvider typeProvider, {StaticTypeAnalyzer typeAnalyzer,
+      StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = new StaticTypeAnalyzer(this);
+    this._typeAnalyzer = typeAnalyzer != null
+        ? typeAnalyzer
+        : (typeAnalyzerFactory != null
+            ? typeAnalyzerFactory(this)
+            : new StaticTypeAnalyzer(this));
   }
 
+
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
@@ skipping 3481 matching lines @@
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       _recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
+    _hasReferenceToSuper = false;
+    super.visitClassDeclaration(node);
+    ClassElementImpl classElement = _getClassElement(node.name);
+    if (classElement != null)  {
+      classElement.hasReferenceToSuper = _hasReferenceToSuper;
+    }
+  }
+
+  @override
+  void visitClassDeclarationInScope(ClassDeclaration node) {
+    super.visitClassDeclarationInScope(node);
     ExtendsClause extendsClause = node.extendsClause;
     WithClause withClause = node.withClause;
     ImplementsClause implementsClause = node.implementsClause;
-    _hasReferenceToSuper = false;
-    super.visitClassDeclaration(node);
     ClassElementImpl classElement = _getClassElement(node.name);
     InterfaceType superclassType = null;
     if (extendsClause != null) {
       ErrorCode errorCode = (withClause == null ?
           CompileTimeErrorCode.EXTENDS_NON_CLASS :
           CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
       superclassType = _resolveType(
           extendsClause.superclass,
           errorCode,
           CompileTimeErrorCode.EXTENDS_ENUM,
           errorCode);
       if (!identical(superclassType, typeProvider.objectType)) {
         classElement.validMixin = false;
       }
     }
     if (classElement != null) {
       if (superclassType == null) {
         InterfaceType objectType = typeProvider.objectType;
         if (!identical(classElement.type, objectType)) {
           superclassType = objectType;
         }
       }
       classElement.supertype = superclassType;
-      classElement.hasReferenceToSuper = _hasReferenceToSuper;
     }
     _resolve(classElement, withClause, implementsClause);
     return null;
   }
 
   @override
   void visitClassMembersInScope(ClassDeclaration node) {
     //
     // Process field declarations before constructors and methods so that the
     // types of field formal parameters can be correctly resolved.
@@ skipping 1693 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>();
 }