Fix for resolving super.method() invocations.

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'ast.dart';
@@ skipping 253 matching lines @@
     _intType = _typeProvider.intType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType>[
         _typeProvider.nullType,
         _typeProvider.numType,
         _intType,
         _typeProvider.doubleType,
         _boolType,
         _typeProvider.stringType];
   }
 
-  /**
-   * Initialize this instance with the given [ClassDeclaration].
-   */
-  void initClassDeclaration(ClassDeclaration node) {
-    _isInNativeClass = node.nativeClause != null;
-    _enclosingClass = node.element;
-    // initialize initialFieldElementsMap
-    if (_enclosingClass != null) {
-      List<FieldElement> fieldElements = _enclosingClass.fields;
-      _initialFieldElementsMap = new HashMap<FieldElement, INIT_STATE>();
-      for (FieldElement fieldElement in fieldElements) {
-        if (!fieldElement.isSynthetic) {
-          _initialFieldElementsMap[fieldElement] =
-              fieldElement.initializer == null ?
-                  INIT_STATE.NOT_INIT :
-                  INIT_STATE.INIT_IN_DECLARATION;
-        }
-      }
-    }
-  }
-
   @override
   Object visitAnnotation(Annotation node) {
     _checkForInvalidAnnotationFromDeferredLibrary(node);
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
@@ skipping 139 matching lines @@
           _checkForImplementsDeferredClass(implementsClause);
           _checkForNonAbstractClassInheritsAbstractMember(node.name);
           _checkForInconsistentMethodInheritance();
           _checkForRecursiveInterfaceInheritance(_enclosingClass);
           _checkForConflictingGetterAndMethod();
           _checkForConflictingInstanceGetterAndSuperclassMember();
           _checkImplementsSuperClass(node);
           _checkImplementsFunctionWithoutCall(node);
         }
       }
-      initClassDeclaration(node);
+      _isInNativeClass = node.nativeClause != null;

[Brian Wilkerson, 2014/11/26 15:30:51]

I must be missing something, but... Why did you inline this instead of just
invoking visitClassDeclarationIncrementally at this point?

[scheglov, 2014/11/26 15:56:18]

Well, in this class implementations of visitClassDeclarationIncrementally() and
corresponding code in visitClassDeclaration() can be shared. But not in
ResolverVisitor. So, I kept them separate here for consistency.

Replaced with an invocation now.

+      _enclosingClass = node.element;
+      // initialize initialFieldElementsMap
+      if (_enclosingClass != null) {
+        List<FieldElement> fieldElements = _enclosingClass.fields;
+        _initialFieldElementsMap = new HashMap<FieldElement, INIT_STATE>();
+        for (FieldElement fieldElement in fieldElements) {
+          if (!fieldElement.isSynthetic) {
+            _initialFieldElementsMap[fieldElement] =
+                fieldElement.initializer == null ?
+                    INIT_STATE.NOT_INIT :
+                    INIT_STATE.INIT_IN_DECLARATION;
+          }
+        }
+      }
       _checkForFinalNotInitializedInClass(node);
       _checkForDuplicateDefinitionInheritance();
       _checkForConflictingInstanceMethodSetter(node);
       return super.visitClassDeclaration(node);
     } finally {
       _isInNativeClass = false;
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
   }
 
+  /**
+   * Implementation of this method should be synchronized with
+   * [visitClassDeclaration].
+   */
+  visitClassDeclarationIncrementally(ClassDeclaration node) {
+    _isInNativeClass = node.nativeClause != null;
+    _enclosingClass = node.element;
+    // initialize initialFieldElementsMap
+    if (_enclosingClass != null) {
+      List<FieldElement> fieldElements = _enclosingClass.fields;
+      _initialFieldElementsMap = new HashMap<FieldElement, INIT_STATE>();
+      for (FieldElement fieldElement in fieldElements) {
+        if (!fieldElement.isSynthetic) {
+          _initialFieldElementsMap[fieldElement] =
+              fieldElement.initializer == null ?
+                  INIT_STATE.NOT_INIT :
+                  INIT_STATE.INIT_IN_DECLARATION;
+        }
+      }
+    }
+  }
+
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     _checkForBuiltInIdentifierAsName(
         node.name,
         CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
       ImplementsClause implementsClause = node.implementsClause;
       // Only check for all of the inheritance logic around clauses if there
@@ skipping 5748 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }