Analyzer snapshot with disabled 'this.field' generation.

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 7653 matching lines @@
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
  * no identifier in the AST when the parser could not distinguish between a method invocation and
  * an invocation of a top-level function imported with a prefix.
  */
 class ElementResolver_SyntheticIdentifier extends Identifier {
   /**
    * The name of the synthetic identifier.
    */
-  final String name;
+  String name;
 
   /**
    * Initialize a newly created synthetic identifier to have the given name.
    *
    * @param name the name of the synthetic identifier
    */
-  ElementResolver_SyntheticIdentifier(this.name);
+  ElementResolver_SyntheticIdentifier(String name) {
+    this.name = name;
+  }
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   sc.Token get beginToken => null;
 
   @override
   Element get bestElement => null;
 
@@ skipping 1032 matching lines @@
   InheritanceManager _inheritanceManager;
 
   /**
    * The listener to which analysis errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The source specifying the defining compilation unit of this library.
    */
-  final Source librarySource;
+  Source librarySource;
 
   /**
    * The library element representing this library.
    */
   LibraryElementImpl _libraryElement;
 
   /**
    * A list containing all of the libraries that are imported into this library.
    */
   List<Library> _importedLibraries = _EMPTY_ARRAY;
@@ skipping 34 matching lines @@
    */
   static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
    * Initialize a newly created data holder that can maintain the data associated with a library.
    *
    * @param analysisContext the analysis context in which this library is being analyzed
    * @param errorListener the listener to which analysis errors will be reported
    * @param librarySource the source specifying the defining compilation unit of this library
    */
-  Library(InternalAnalysisContext analysisContext, AnalysisErrorListener errorListener, this.librarySource) {
+  Library(InternalAnalysisContext analysisContext, AnalysisErrorListener errorListener, Source librarySource) {
     this._analysisContext = analysisContext;
     this._errorListener = errorListener;
+    this.librarySource = librarySource;
     this._libraryElement = analysisContext.getLibraryElement(librarySource) as LibraryElementImpl;
   }
 
   /**
    * Return the AST structure associated with the given source.
    *
    * @param source the source representing the compilation unit whose AST is to be returned
    * @return the AST structure associated with the given source
    * @throws AnalysisException if an AST structure could not be created for the compilation unit
    */
@@ skipping 169 matching lines @@
 
   /**
    * Set the AST structure associated with the defining compilation unit for this library to the
    * given AST structure.
    *
    * @param modificationStamp the modification time of the source from which the compilation unit
    *          was created
    * @param unit the AST structure associated with the defining compilation unit for this library
    */
   void setDefiningCompilationUnit(int modificationStamp, CompilationUnit unit) {
-    _astMap[librarySource] = new ResolvableCompilationUnit(modificationStamp, unit);
+    _astMap[librarySource] = new ResolvableCompilationUnit.con1(modificationStamp, unit);
   }
 
   /**
    * Set the libraries that are exported by this library to be those in the given array.
    *
    * @param exportedLibraries the libraries that are exported by this library
    */
   void set exportedLibraries(List<Library> exportedLibraries) {
     this._exportedLibraries = exportedLibraries;
   }
@@ skipping 224 matching lines @@
 }
 
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  */
 class LibraryResolver {
   /**
    * The analysis context in which the libraries are being analyzed.
    */
-  final InternalAnalysisContext analysisContext;
+  InternalAnalysisContext analysisContext;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
@@ skipping 18 matching lines @@
   /**
    * A collection containing the libraries that are being resolved together.
    */
   Set<Library> _librariesInCycles;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
-  LibraryResolver(this.analysisContext) {
+  LibraryResolver(InternalAnalysisContext analysisContext) {
+    this.analysisContext = analysisContext;
     this._errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
   }
 
   /**
    * Return the listener to which analysis errors will be reported.
    *
    * @return the listener to which analysis errors will be reported
    */
   RecordingErrorListener get errorListener => _errorListener;
@@ skipping 843 matching lines @@
 class ProxyConditionalAnalysisError {
   /**
    * The enclosing [ClassElement], this is what will determine if the error code should, or
    * should not, be generated on the source.
    */
   Element _enclosingElement;
 
   /**
    * The conditional analysis error.
    */
-  final AnalysisError analysisError;
+  AnalysisError analysisError;
 
   /**
    * Instantiate a new [ProxyConditionalAnalysisError] with some enclosing element and the
    * conditional analysis error.
    *
    * @param enclosingElement the enclosing element
    * @param analysisError the conditional analysis error
    */
-  ProxyConditionalAnalysisError(Element enclosingElement, this.analysisError) {
+  ProxyConditionalAnalysisError(Element enclosingElement, AnalysisError analysisError) {
     this._enclosingElement = enclosingElement;
+    this.analysisError = analysisError;
   }
 
   /**
    * Return `true` iff the enclosing class has the proxy annotation.
    *
    * @return `true` iff the enclosing class has the proxy annotation
    */
   bool shouldIncludeErrorCode() {
     if (_enclosingElement is ClassElement) {
       return !(_enclosingElement as ClassElement).isOrInheritsProxy;
@@ skipping 1314 matching lines @@
  */
 abstract class ScopedVisitor extends UnifyingAstVisitor<Object> {
   /**
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement _definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
-  final Source source;
+  Source source;
 
   /**
    * The error listener that will be informed of any errors that are found during resolution.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The scope used to resolve identifiers.
    */
   Scope _nameScope;
 
   /**
    * The object used to access the types from the core library.
    */
-  final TypeProvider typeProvider;
+  TypeProvider typeProvider;
 
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
 
   /**
    * 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
    */
-  ScopedVisitor.con1(Library library, this.source, this.typeProvider) {
+  ScopedVisitor.con1(Library library, Source source, TypeProvider typeProvider) {
     this._definingLibrary = library.libraryElement;
+    this.source = source;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
     this._nameScope = libraryScope;
+    this.typeProvider = typeProvider;
   }
 
   /**
    * 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
    */
-  ScopedVisitor.con2(LibraryElement definingLibrary, this.source, this.typeProvider, AnalysisErrorListener errorListener) {
+  ScopedVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
+    this.source = source;
     this._errorListener = errorListener;
     this._nameScope = new LibraryScope(definingLibrary, errorListener);
+    this.typeProvider = typeProvider;
   }
 
   /**
    * 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 nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ScopedVisitor.con3(LibraryElement definingLibrary, this.source, this.typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
+  ScopedVisitor.con3(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
+    this.source = source;
     this._errorListener = errorListener;
     this._nameScope = nameScope;
+    this.typeProvider = typeProvider;
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    *
    * @return the library element for the library containing the compilation unit being resolved
    */
   LibraryElement get definingLibrary => _definingLibrary;
 
   /**
@@ skipping 4224 matching lines @@
 }
 
 /**
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  */
 class EnclosedScope extends Scope {
   /**
    * The scope in which this scope is lexically enclosed.
    */
-  final Scope enclosingScope;
+  Scope enclosingScope;
 
   /**
    * A table mapping names that will be defined in this scope, but right now are not initialized.
    * According to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
   Map<String, Element> _hiddenElements = new Map<String, Element>();
 
   /**
    * A flag indicating whether there are any names defined in this scope.
    */
   bool _hasHiddenName = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    */
-  EnclosedScope(this.enclosingScope);
+  EnclosedScope(Scope enclosingScope) {
+    this.enclosingScope = enclosingScope;
+  }
 
   @override
   AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
   /**
    * Record that given element is declared in this scope, but hasn't been initialized yet, so it is
    * error to use. If there is already an element with the given name defined in an outer scope,
    * then it will become unavailable.
    *
    * @param element the element declared, but not initialized in this scope
@@ skipping 194 matching lines @@
  */
 class LibraryImportScope extends Scope {
   /**
    * The element representing the library in which this scope is enclosed.
    */
   LibraryElement _definingLibrary;
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
-  final AnalysisErrorListener errorListener;
+  AnalysisErrorListener errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
   List<Namespace> _importedNamespaces;
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
-  LibraryImportScope(LibraryElement definingLibrary, this.errorListener) {
+  LibraryImportScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
+    this.errorListener = errorListener;
     _createImportedNamespaces(definingLibrary);
   }
 
   @override
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
 
@@ skipping 4658 matching lines @@
     for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
       String memberName = membersInheritedFromInterfaces.getKey(i);
       ExecutableElement executableElt = membersInheritedFromInterfaces.getValue(i);
       if (memberName == null) {
         break;
       }
       // If the element is not synthetic and can be determined to be defined in Object, skip it.
       if (executableElt.enclosingElement != null && (executableElt.enclosingElement as ClassElement).type.isObject) {
         continue;
       }
-      // Reference the type of the enclosing class
-      InterfaceType enclosingType = _enclosingClass.type;
       // Check to see if some element is in local enclosing class that matches the name of the
       // required member.
       if (_isMemberInClassOrMixin(executableElt, _enclosingClass)) {
         // We do not have to verify that this implementation of the found method matches the
         // required function type: the set of StaticWarningCode.INVALID_METHOD_OVERRIDE_* warnings
         // break out the different specific situations.
         continue;
       }
       // First check to see if this element was declared in the superclass chain, in which case
       // there is already a concrete implementation.
-      ExecutableElement elt = membersInheritedFromSuperclasses.get(executableElt.name);
+      ExecutableElement elt = membersInheritedFromSuperclasses.get(memberName);
       // Check to see if an element was found in the superclass chain with the correct name.
       if (elt != null) {
+        // Reference the types, if any are null then continue.
+        InterfaceType enclosingType = _enclosingClass.type;
+        FunctionType concreteType = elt.type;
+        FunctionType requiredMemberType = executableElt.type;
+        if (enclosingType == null || concreteType == null || requiredMemberType == null) {
+          continue;
+        }
         // Some element was found in the superclass chain that matches the name of the required
         // member.
         // If it is not abstract and it is the correct one (types match- the version of this method
         // that we have has the correct number of parameters, etc), then this class has a valid
         // implementation of this method, so skip it.
         if ((elt is MethodElement && !elt.isAbstract) || (elt is PropertyAccessorElement && !elt.isAbstract)) {
           // Since we are comparing two function types, we need to do the appropriate type
           // substitutions first ().
-          FunctionType foundConcreteFT = _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(elt.type, executableElt.name, enclosingType);
-          FunctionType requiredMemberFT = _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(executableElt.type, executableElt.name, enclosingType);
+          FunctionType foundConcreteFT = _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(concreteType, memberName, enclosingType);
+          FunctionType requiredMemberFT = _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(requiredMemberType, memberName, enclosingType);
           if (foundConcreteFT.isSubtypeOf(requiredMemberFT)) {
             continue;
           }
         }
       }
       // The not qualifying concrete executable element was found, add it to the list.
       missingOverrides.add(executableElt);
     }
     // Now that we have the set of missing overrides, generate a warning on this class
     int missingOverridesSize = missingOverrides.length;
@@ skipping 1343 matching lines @@
   static final ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART = new ResolverErrorCode.con1('MISSING_LIBRARY_DIRECTIVE_WITH_PART', 2, ErrorType.COMPILE_TIME_ERROR, "Libraries that have parts must have a library directive");
 
   static final List<ResolverErrorCode> values = [
       BREAK_LABEL_ON_SWITCH_MEMBER,
       CONTINUE_LABEL_ON_SWITCH,
       MISSING_LIBRARY_DIRECTIVE_WITH_PART];
 
   /**
    * The type of this error.
    */
-  final ErrorType type;
+  ErrorType type;
 
   /**
    * The template used to create the message to be displayed for this error.
    */
-  final String message;
+  String message;
 
   /**
    * The template used to create the correction to be displayed for this error, or `null` if
    * there is no correction information for this error.
    */
   String correction9;
 
   /**
    * Initialize a newly created error code to have the given type and message.
    *
    * @param type the type of this error
    * @param message the message template used to create the message to be displayed for the error
    */
-  ResolverErrorCode.con1(String name, int ordinal, this.type, this.message) : super(name, ordinal);
+  ResolverErrorCode.con1(String name, int ordinal, ErrorType type, String message) : super(name, ordinal) {
+    this.type = type;
+    this.message = message;
+  }
 
   /**
    * Initialize a newly created error code to have the given type, message and correction.
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
-  ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, String correction) : super(name, ordinal) {
+  ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
+    this.type = type;
+    this.message = message;
     this.correction9 = correction;
   }
 
   @override
   String get correction => correction9;
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 }