New analyzer snapshot.

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
@@ skipping 1216 matching lines @@
 /**
  * Instances of the class `ClassScope` implement the scope defined by a class.
  */
 class ClassScope extends EnclosedScope {
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type represented by this scope
    */
-  ClassScope(Scope enclosingScope, ClassElement typeElement) : super(new EnclosedScope(enclosingScope)) {
+  ClassScope(Scope enclosingScope, ClassElement typeElement) : super(enclosingScope) {
     if (typeElement == null) {
       throw new IllegalArgumentException("class element cannot be null");
     }
-    _defineTypeParameters(typeElement);
     _defineMembers(typeElement);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PropertyAccessorElement && duplicate is MethodElement) {
       if (existing.nameOffset < duplicate.nameOffset) {
         return new AnalysisError.con2(duplicate.source, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME, [existing.displayName]);
       } else {
         return new AnalysisError.con2(existing.source, existing.nameOffset, existing.displayName.length, CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME, [existing.displayName]);
       }
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Define the instance members defined by the class.
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void _defineMembers(ClassElement typeElement) {
     for (PropertyAccessorElement accessor in typeElement.accessors) {
       define(accessor);
     }
     for (MethodElement method in typeElement.methods) {
       define(method);
     }
   }
-
-  /**
-   * Define the type parameters for the class.
-   *
-   * @param typeElement the element representing the type represented by this scope
-   */
-  void _defineTypeParameters(ClassElement typeElement) {
-    Scope parameterScope = enclosingScope;
-    for (TypeParameterElement typeParameter in typeElement.typeParameters) {
-      parameterScope.define(typeParameter);
-    }
-  }
 }
 
 /**
  * Instances of the class `CompilationUnitBuilder` build an element model for a single
  * compilation unit.
  */
 class CompilationUnitBuilder {
   /**
    * Build the compilation unit element for the given source.
    *
@@ skipping 16728 matching lines @@
     if (node.metadata != null) {
       node.metadata.accept(this);
     }
     _enclosingClassDeclaration = node;
     // Continue the class resolution.
     ClassElement outerType = _enclosingClass;
     try {
       _enclosingClass = node.element;
       _typeAnalyzer.thisType = _enclosingClass == null ? null : _enclosingClass.type;
       super.visitClassDeclaration(node);
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
     } finally {
       _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
       _enclosingClass = outerType;
       _enclosingClassDeclaration = null;
     }
     return null;
   }
 
   @override
   Object visitComment(Comment node) {
@@ skipping 1282 matching lines @@
     AstNode parent = node.parent;
     if (parent == null) {
       throw new AnalysisException("Cannot create scope: node is not part of a CompilationUnit");
     }
     Scope scope = _scopeForAstNode(parent);
     if (node is ClassDeclaration) {
       ClassElement element = node.element;
       if (element == null) {
         throw new AnalysisException("Cannot build a scope for an unresolved class");
       }
-      scope = new ClassScope(scope, element);
+      scope = new ClassScope(new TypeParameterScope(scope, element), element);
     } else if (node is ClassTypeAlias) {
       ClassElement element = node.element;
       if (element == null) {
         throw new AnalysisException("Cannot build a scope for an unresolved class type alias");
       }
-      scope = new ClassScope(scope, element);
+      scope = new ClassScope(new TypeParameterScope(scope, element), element);
     } else if (node is ConstructorDeclaration) {
       ConstructorElement element = node.element;
       if (element == null) {
         throw new AnalysisException("Cannot build a scope for an unresolved constructor");
       }
       FunctionScope functionScope = new FunctionScope(scope, element);
       functionScope.defineParameters();
       scope = functionScope;
     } else if (node is FunctionDeclaration) {
       ExecutableElement element = node.element;
@@ skipping 190 matching lines @@
     }
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
     Scope outerScope = _nameScope;
     try {
       if (classElement == null) {
-        AnalysisEngine.instance.logger.logInformation2("Missing element for constructor ${node.name.name} in ${definingLibrary.source.fullName}", new JavaException());
+        AnalysisEngine.instance.logger.logInformation2("Missing element for class declaration ${node.name.name} in ${definingLibrary.source.fullName}", new JavaException());
+        super.visitClassDeclaration(node);
       } else {
+        _nameScope = new TypeParameterScope(_nameScope, classElement);
+        visitClassDeclarationInScope(node);
         _nameScope = new ClassScope(_nameScope, classElement);
+        visitClassMembersInScope(node);
       }
-      visitClassDeclarationInScope(node);
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     Scope outerScope = _nameScope;
     try {
-      _nameScope = new ClassScope(_nameScope, node.element);
+      ClassElement element = node.element;
+      _nameScope = new ClassScope(new TypeParameterScope(_nameScope, element), element);
       super.visitClassTypeAlias(node);
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
@@ skipping 310 matching lines @@
    *
    * @param node the node to be visited
    */
   void safelyVisit(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
   void visitClassDeclarationInScope(ClassDeclaration node) {
-    super.visitClassDeclaration(node);
+    safelyVisit(node.name);
+    safelyVisit(node.typeParameters);
+    safelyVisit(node.extendsClause);
+    safelyVisit(node.withClause);
+    safelyVisit(node.implementsClause);
+    safelyVisit(node.nativeClause);
+  }
+
+  void visitClassMembersInScope(ClassDeclaration node) {
+    safelyVisit(node.documentationComment);
+    node.metadata.accept(this);
+    node.members.accept(this);
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
    * @param node the statement to be visited
    */
   void visitForEachStatementInScope(ForEachStatement node) {
@@ skipping 2149 matching lines @@
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(Element element, DartType type) {
     _overridenTypes[element] = type;
   }
 }
 
 /**
+ * Instances of the class `TypeParameterScope` implement the scope defined by the type
+ * parameters in a class.
+ */
+class TypeParameterScope extends EnclosedScope {
+  /**
+   * Initialize a newly created scope enclosed within another scope.
+   *
+   * @param enclosingScope the scope in which this scope is lexically enclosed
+   * @param typeElement the element representing the type represented by this scope
+   */
+  TypeParameterScope(Scope enclosingScope, ClassElement typeElement) : super(enclosingScope) {
+    if (typeElement == null) {
+      throw new IllegalArgumentException("class element cannot be null");
+    }
+    _defineTypeParameters(typeElement);
+  }
+
+  /**
+   * Define the type parameters for the class.
+   *
+   * @param typeElement the element representing the type represented by this scope
+   */
+  void _defineTypeParameters(ClassElement typeElement) {
+    for (TypeParameterElement typeParameter in typeElement.typeParameters) {
+      define(typeParameter);
+    }
+  }
+}
+
+/**
  * Instances of the class `TypePromotionManager` manage the ability to promote types of local
  * variables and formal parameters from their declared types based on control flow.
  */
 class TypePromotionManager {
   /**
    * The current promotion scope, or `null` if no scope has been entered.
    */
   TypePromotionManager_TypePromoteScope _currentScope;
 
   /**
@@ skipping 562 matching lines @@
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       _recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration 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;
-    ExtendsClause extendsClause = node.extendsClause;
     if (extendsClause != null) {
-      ErrorCode errorCode = (node.withClause == null ? CompileTimeErrorCode.EXTENDS_NON_CLASS : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
+      ErrorCode errorCode = (withClause == null ? CompileTimeErrorCode.EXTENDS_NON_CLASS : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
       superclassType = _resolveType(extendsClause.superclass, errorCode, 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, node.withClause, node.implementsClause);
+    _resolve(classElement, withClause, implementsClause);
     return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
     ClassElementImpl classElement = _getClassElement(node.name);
     ErrorCode errorCode = CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
     InterfaceType superclassType = _resolveType(node.superclass, errorCode, errorCode);
     if (superclassType == null) {
@@ skipping 433 matching lines @@
           }
           setter.type = setterType;
         }
       }
     } else {
     }
     return null;
   }
 
   @override
-  void visitClassDeclarationInScope(ClassDeclaration node) {
+  void visitClassMembersInScope(ClassDeclaration node) {
     //
     // Process field declarations before constructors and methods so that the types of field formal
     // parameters can be correctly resolved.
     //
     List<ClassMember> nonFields = new List<ClassMember>();
-    node.visitChildren(new UnifyingAstVisitor_TypeResolverVisitor_visitClassDeclarationInScope(this, nonFields));
+    node.visitChildren(new UnifyingAstVisitor_TypeResolverVisitor_visitClassMembersInScope(this, nonFields));
     int count = nonFields.length;
     for (int i = 0; i < count; i++) {
       nonFields[i].accept(this);
     }
   }
 
   /**
    * Given a type name representing the return type of a function, compute the return type of the
    * function.
    *
@@ skipping 470 matching lines @@
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(ElementBuilder_this);
 }
 
-class UnifyingAstVisitor_TypeResolverVisitor_visitClassDeclarationInScope extends UnifyingAstVisitor<Object> {
+class UnifyingAstVisitor_TypeResolverVisitor_visitClassMembersInScope extends UnifyingAstVisitor<Object> {
   final TypeResolverVisitor TypeResolverVisitor_this;
 
   List<ClassMember> nonFields;
 
-  UnifyingAstVisitor_TypeResolverVisitor_visitClassDeclarationInScope(this.TypeResolverVisitor_this, this.nonFields) : super();
+  UnifyingAstVisitor_TypeResolverVisitor_visitClassMembersInScope(this.TypeResolverVisitor_this, this.nonFields) : super();
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
+  Object visitExtendsClause(ExtendsClause node) => null;
+
+  @override
+  Object visitImplementsClause(ImplementsClause node) => null;
+
+  @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
+
+  @override
+  Object visitWithClause(WithClause node) => null;
 }
 
 /**
  * Instances of the class `VariableResolverVisitor` are used to resolve
  * [SimpleIdentifier]s to local variables and formal parameters.
  */
 class VariableResolverVisitor extends ScopedVisitor {
   /**
    * The method or function that we are currently visiting, or `null` if we are not inside a
    * method or function.
@@ skipping 102 matching lines @@
         parameterImpl.markPotentiallyMutatedInScope();
         // If we are in some closure, check if it is not the same as where variable is declared.
         if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
           parameterImpl.markPotentiallyMutatedInClosure();
         }
       }
     }
     return null;
   }
 }