Analyzer snapshot with disabled 'this.field' generation.

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 585 matching lines @@
    * @return the offset of the name of this element
    */
   int get nameOffset;
 
   /**
    * Return the resolved [AstNode] node that declares this [Element].
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @return the resolved [AstNode], maybe `null` if [Element] is synthetic or
    *         isn't contained in a compilation unit, such as a [LibraryElement].
    */
   AstNode get node;
 
   /**
    * Return the source that contains this element, or `null` if this element is not contained
    * in a source.
    *
    * @return the source that contains this element
@@ skipping 224 matching lines @@
   static ElementKind of(Element element) {
     if (element == null) {
       return ERROR;
     }
     return element.kind;
   }
 
   /**
    * The name displayed in the UI for this kind of element.
    */
-  final String displayName;
+  String displayName;
 
   /**
    * Initialize a newly created element kind to have the given display name.
    *
    * @param displayName the name displayed in the UI for this kind of element
    */
-  ElementKind(String name, int ordinal, this.displayName) : super(name, ordinal);
+  ElementKind(String name, int ordinal, String displayName) : super(name, ordinal) {
+    this.displayName = displayName;
+  }
 }
 
 /**
  * The interface `ElementLocation` defines the behavior of objects that represent the location
  * of an element within the element model.
  */
 abstract class ElementLocation {
   /**
    * Return an encoded representation of this location that can be used to create a location that is
    * equal to this location.
@@ skipping 875 matching lines @@
 abstract class UriReferencedElement implements Element {
   /**
    * Return the offset of the character immediately following the last character of this node's URI,
    * or `-1` for synthetic import.
    *
    * @return the offset of the character just past the node's URI
    */
   int get uriEnd;
 
   /**
-   * Return the offset of the URU in the file, or `-1` if this element is synthetic.
+   * Return the offset of the URI in the file, or `-1` if this element is synthetic.
    *
    * @return the offset of the URI
    */
   int get uriOffset;
 
   /**
    * Return the URI that is used to include this element into the enclosing library, or `null`
    * if this is the defining compilation unit of a library.
    *
    * @return the URI that is used to include this element into the enclosing library
@@ skipping 792 matching lines @@
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
   /**
    * The element based on propagated type information, or `null` if the AST structure has not
    * been resolved or if this identifier could not be resolved.
    */
-  final ExecutableElement propagatedElement;
+  ExecutableElement propagatedElement;
 
   /**
    * The element associated with this identifier based on static type information, or `null`
    * if the AST structure has not been resolved or if this identifier could not be resolved.
    */
-  final ExecutableElement staticElement;
+  ExecutableElement staticElement;
 
   /**
    * Create the [AuxiliaryElements] with a static and propagated [ExecutableElement].
    *
    * @param staticElement the static element
    * @param propagatedElement the propagated element
    */
-  AuxiliaryElements(this.staticElement, this.propagatedElement);
+  AuxiliaryElements(ExecutableElement staticElement, ExecutableElement propagatedElement) {
+    this.staticElement = staticElement;
+    this.propagatedElement = propagatedElement;
+  }
 }
 
 /**
  * Instances of the class `ClassElementImpl` implement a `ClassElement`.
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
   /**
    * An array containing all of the accessors (getters and setters) contained in this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
@@ skipping 1063 matching lines @@
   ElementKind get kind => ElementKind.DYNAMIC;
 }
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
-  final Element element;
+  Element element;
 
   /**
    * An empty array of annotations.
    */
   static List<ElementAnnotationImpl> EMPTY_ARRAY = new List<ElementAnnotationImpl>(0);
 
   /**
    * The name of the class used to mark an element as being deprecated.
    */
   static String _DEPRECATED_CLASS_NAME = "Deprecated";
@@ skipping 13 matching lines @@
    * The name of the top-level variable used to mark a class as implementing a proxy object.
    */
   static String _PROXY_VARIABLE_NAME = "proxy";
 
   /**
    * Initialize a newly created annotation.
    *
    * @param element the element representing the field, variable, or constructor being used as an
    *          annotation
    */
-  ElementAnnotationImpl(this.element);
+  ElementAnnotationImpl(Element element) {
+    this.element = element;
+  }
 
   @override
   bool get isDeprecated {
     if (element != null) {
       LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
         if (element is ConstructorElement) {
           ConstructorElement constructorElement = element as ConstructorElement;
           if (constructorElement.enclosingElement.name == _DEPRECATED_CLASS_NAME) {
             return true;
@@ skipping 80 matching lines @@
    */
   ElementImpl.forNode(Identifier name) : this(name == null ? "" : name.name, name == null ? -1 : name.offset);
 
   /**
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
-  ElementImpl(String name, this.nameOffset) {
+  ElementImpl(String name, int nameOffset) {
     this._name = StringUtilities.intern(name);
+    this.nameOffset = nameOffset;
   }
 
   @override
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
@@ skipping 1127 matching lines @@
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
    */
   static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>(0);
 
   /**
    * The analysis context in which this library is defined.
    */
-  final AnalysisContext context;
+  AnalysisContext context;
 
   /**
    * The scripts contained in or referenced from script tags in the HTML file.
    */
   List<HtmlScriptElement> _scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
 
   /**
    * The source that corresponds to this HTML file.
    */
   Source source;
 
   /**
    * The element associated with Dart pieces in this HTML unit or `null` if the receiver is
    * not resolved.
    */
   CompilationUnitElement angularCompilationUnit;
 
   /**
    * Initialize a newly created HTML element to have the given name.
    *
    * @param context the analysis context in which the HTML file is defined
    * @param name the name of this element
    */
-  HtmlElementImpl(this.context, String name) : super(name, -1);
+  HtmlElementImpl(AnalysisContext context, String name) : super(name, -1) {
+    this.context = context;
+  }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
 
   @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object == null) {
@@ skipping 215 matching lines @@
           return false;
         }
       }
     }
     return true;
   }
 
   /**
    * The analysis context in which this library is defined.
    */
-  final AnalysisContext context;
+  AnalysisContext context;
 
   /**
    * The compilation unit that defines this library.
    */
   CompilationUnitElement _definingCompilationUnit;
 
   /**
    * The entry point for this library, or `null` if this library does not have an entry point.
    */
   FunctionElement entryPoint;
@@ skipping 18 matching lines @@
    * Is `true` if this library is created for Angular analysis.
    */
   bool _isAngularHtml = false;
 
   /**
    * Initialize a newly created library element to have the given name.
    *
    * @param context the analysis context in which the library is defined
    * @param name the name of this element
    */
-  LibraryElementImpl(this.context, LibraryIdentifier name) : super.forNode(name);
+  LibraryElementImpl(AnalysisContext context, LibraryIdentifier name) : super.forNode(name) {
+    this.context = context;
+  }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
   @override
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == (object as LibraryElementImpl).definingCompilationUnit;
 
   @override
   ElementImpl getChild(String identifier) {
     if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier == identifier) {
@@ skipping 604 matching lines @@
   static List<Element> _computeConflictingElements(Element firstElement, Element secondElement) {
     Set<Element> elements = new Set<Element>();
     _add(elements, firstElement);
     _add(elements, secondElement);
     return new List.from(elements);
   }
 
   /**
    * The analysis context in which the multiply defined elements are defined.
    */
-  final AnalysisContext context;
+  AnalysisContext context;
 
   /**
    * The name of the conflicting elements.
    */
   String _name;
 
   /**
    * A list containing all of the elements that conflict.
    */
-  final List<Element> conflictingElements;
+  List<Element> conflictingElements;
 
   /**
    * Initialize a newly created element to represent a list of conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
    * @param conflictingElements the elements that conflict
    */
-  MultiplyDefinedElementImpl(this.context, this.conflictingElements) {
+  MultiplyDefinedElementImpl(AnalysisContext context, List<Element> conflictingElements) {
+    this.context = context;
     _name = conflictingElements[0].name;
+    this.conflictingElements = conflictingElements;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
   @override
   String computeDocumentationComment() => null;
 
   @override
   Element getAncestor(Predicate<Element> predicate) => null;
@@ skipping 686 matching lines @@
     }
   }
 }
 
 /**
  * Instances of the class `UriReferencedElementImpl` implement an [UriReferencedElement]
  * .
  */
 abstract class UriReferencedElementImpl extends ElementImpl implements UriReferencedElement {
   /**
-   * The offset of the URU in the file, may be `-1` if synthetic.
+   * The offset of the URI in the file, may be `-1` if synthetic.
    */
   int uriOffset = -1;
 
   /**
    * The offset of the character immediately following the last character of this node's URI, may be
    * `-1` if synthetic.
    */
   int uriEnd = -1;
 
   /**
@@ skipping 136 matching lines @@
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 }
 
 /**
  * Information about Angular application.
  */
 class AngularApplication {
-  final Source entryPoint;
+  Source entryPoint;
 
   Set<Source> _librarySources;
 
-  final List<AngularElement> elements;
+  List<AngularElement> elements;
 
-  final List<Source> elementSources;
+  List<Source> elementSources;
 
-  AngularApplication(this.entryPoint, Set<Source> librarySources, this.elements, this.elementSources) {
+  AngularApplication(Source entryPoint, Set<Source> librarySources, List<AngularElement> elements, List<Source> elementSources) {
+    this.entryPoint = entryPoint;
     this._librarySources = librarySources;
+    this.elements = elements;
+    this.elementSources = elementSources;
   }
 
   /**
    * Checks if this application depends on the library with the given [Source].
    */
   bool dependsOn(Source librarySource) => _librarySources.contains(librarySource);
 }
 
 /**
  * Implementation of `AngularComponentElement`.
@@ skipping 329 matching lines @@
   ElementKind get kind => ElementKind.ANGULAR_PROPERTY;
 }
 
 /**
  * Implementation of `AngularScopePropertyElement`.
  */
 class AngularScopePropertyElementImpl extends AngularElementImpl implements AngularScopePropertyElement {
   /**
    * The type of the property
    */
-  final DartType type;
+  DartType type;
 
   /**
    * Initialize a newly created Angular scope property to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
-  AngularScopePropertyElementImpl(String name, int nameOffset, this.type) : super(name, nameOffset);
+  AngularScopePropertyElementImpl(String name, int nameOffset, DartType type) : super(name, nameOffset) {
+    this.type = type;
+  }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularScopePropertyElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_SCOPE_PROPERTY;
 }
 
 /**
  * Implementation of `AngularFilterElement`.
@@ skipping 31 matching lines @@
   AngularApplication get application => (enclosingElement as AngularElementImpl).application;
 }
 
 /**
  * Implementation of `AngularViewElement`.
  */
 class AngularViewElementImpl extends AngularElementImpl implements AngularViewElement {
   /**
    * The HTML template URI.
    */
-  final String templateUri;
+  String templateUri;
 
   /**
    * The offset of the [templateUri] in the [getSource].
    */
-  final int templateUriOffset;
+  int templateUriOffset = 0;
 
   /**
    * The HTML template source.
    */
   Source templateSource;
 
   /**
    * Initialize a newly created Angular view.
    */
-  AngularViewElementImpl(this.templateUri, this.templateUriOffset) : super(null, -1);
+  AngularViewElementImpl(String templateUri, int templateUriOffset) : super(null, -1) {
+    this.templateUri = templateUri;
+    this.templateUriOffset = templateUriOffset;
+  }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularViewElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_VIEW;
 
   @override
   String get identifier => "AngularView@${templateUriOffset}";
 }
@@ skipping 15 matching lines @@
     builder.append("[");
     builder.append(name);
     builder.append("]");
   }
 }
 
 /**
  * Combination of [AngularTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
  */
 class IsTagHasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
-  final String tagName;
+  String tagName;
 
-  final String attributeName;
+  String attributeName;
 
-  IsTagHasAttributeSelectorElementImpl(this.tagName, this.attributeName) : super(null, -1);
+  IsTagHasAttributeSelectorElementImpl(String tagName, String attributeName) : super(null, -1) {
+    this.tagName = tagName;
+    this.attributeName = attributeName;
+  }
 
   @override
   bool apply(XmlTagNode node) => node.tag == tagName && node.getAttribute(attributeName) != null;
 }
 
 /**
  * Instances of the class `ConstructorMember` represent a constructor element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ConstructorMember extends ExecutableMember implements ConstructorElement {
@@ skipping 2253 matching lines @@
 
   /**
    * The element representing the declaration of this type, or `null` if the type has not, or
    * cannot, be associated with an element.
    */
   Element _element;
 
   /**
    * The name of this type, or `null` if the type does not have a name.
    */
-  final String name;
+  String name;
 
   /**
    * An empty array of types.
    */
   static List<DartType> EMPTY_ARRAY = new List<DartType>(0);
 
   /**
    * Initialize a newly created type to be declared by the given element and to have the given name.
    *
    * @param element the element representing the declaration of the type
    * @param name the name of the type
    */
-  TypeImpl(Element element, this.name) {
+  TypeImpl(Element element, String name) {
     this._element = element;
+    this.name = name;
   }
 
   @override
   String get displayName => name;
 
   @override
   Element get element => _element;
 
   @override
   DartType getLeastUpperBound(DartType type) => null;
@@ skipping 891 matching lines @@
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }