Support for @DartName and @DartOptional annotations.

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 2510 matching lines @@
   /**
    * An empty array of class elements.
    */
   static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
 
   /**
    * Initialize a newly created class element to have the given name.
    *
    * @param name the name of this element
    */
-  ClassElementImpl(Identifier name) : super.con1(name);
+  ClassElementImpl(Identifier name) : super.forNode(name);
 
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
 
   List<PropertyAccessorElement> get accessors => _accessors;
 
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
     return new List.from(list);
   }
@@ skipping 486 matching lines @@
   /**
    * An array containing all of the Angular views contained in this compilation unit.
    */
   List<AngularViewElement> _angularViews = AngularViewElement.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created compilation unit element to have the given name.
    *
    * @param name the name of this element
    */
-  CompilationUnitElementImpl(String name) : super.con2(name, -1);
+  CompilationUnitElementImpl(String name) : super(name, -1);
 
   accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
 
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && source == (object as CompilationUnitElementImpl).source;
 
   List<PropertyAccessorElement> get accessors => _accessors;
 
   List<AngularViewElement> get angularViews => _angularViews;
 
   ElementImpl getChild(String identifier) {
@@ skipping 396 matching lines @@
   /**
    * The type defined by this element.
    */
   DynamicTypeImpl type;
 
   /**
    * Initialize a newly created instance of this class. Instances of this class should <b>not</b> be
    * created except as part of creating the type associated with this element. The single instance
    * of this class should be accessed through the method [getInstance].
    */
-  DynamicElementImpl() : super.con2(Keyword.DYNAMIC.syntax, -1) {
+  DynamicElementImpl() : super(Keyword.DYNAMIC.syntax, -1) {
     setModifier(Modifier.SYNTHETIC, true);
   }
 
   accept(ElementVisitor visitor) => null;
 
   ElementKind get kind => ElementKind.DYNAMIC;
 }
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
@@ skipping 117 matching lines @@
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode = 0;
 
   /**
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    */
-  ElementImpl.con1(Identifier name) : this.con2(name == null ? "" : name.name, name == null ? -1 : name.offset);
+  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.con2(String name, this.nameOffset) {
+  ElementImpl(String name, this.nameOffset) {
     this._name = StringUtilities.intern(name);
   }
 
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
@@ skipping 541 matching lines @@
   /**
    * An empty array of executable elements.
    */
   static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>(0);
 
   /**
    * Initialize a newly created executable element to have the given name.
    *
    * @param name the name of this element
    */
-  ExecutableElementImpl.con1(Identifier name) : super.con1(name);
+  ExecutableElementImpl.con1(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created executable 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
    */
-  ExecutableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
+  ExecutableElementImpl.con2(String name, int nameOffset) : super(name, nameOffset);
 
   ElementImpl getChild(String identifier) {
     for (ExecutableElement function in _functions) {
       if ((function as ExecutableElementImpl).identifier == identifier) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
       if ((label as LabelElementImpl).identifier == identifier) {
         return label as LabelElementImpl;
@@ skipping 135 matching lines @@
 
   /**
    * The combinators that were specified as part of the export directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created export element.
    */
-  ExportElementImpl() : super.con1(null);
+  ExportElementImpl() : super.forNode(null);
 
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
   ElementKind get kind => ElementKind.EXPORT;
 
   void appendTo(JavaStringBuilder builder) {
     builder.append("export ");
     (exportedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
@@ skipping 189 matching lines @@
   /**
    * An empty array of type alias elements.
    */
   static List<FunctionTypeAliasElement> EMPTY_ARRAY = new List<FunctionTypeAliasElement>(0);
 
   /**
    * Initialize a newly created type alias element to have the given name.
    *
    * @param name the name of this element
    */
-  FunctionTypeAliasElementImpl(Identifier name) : super.con1(name);
+  FunctionTypeAliasElementImpl(Identifier name) : super.forNode(name);
 
   accept(ElementVisitor visitor) => visitor.visitFunctionTypeAliasElement(this);
 
   ElementImpl getChild(String identifier) {
     for (VariableElement parameter in _parameters) {
       if ((parameter as VariableElementImpl).identifier == identifier) {
         return parameter as VariableElementImpl;
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
@@ skipping 152 matching lines @@
    * 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.con2(name, -1);
+  HtmlElementImpl(this.context, String name) : super(name, -1);
 
   accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
 
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object == null) {
       return false;
     }
@@ skipping 42 matching lines @@
   /**
    * An empty array of HTML script elements.
    */
   static List<HtmlScriptElement> EMPTY_ARRAY = new List<HtmlScriptElement>(0);
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
-  HtmlScriptElementImpl(XmlTagNode node) : super.con2(node.tag, node.tagToken.offset);
+  HtmlScriptElementImpl(XmlTagNode node) : super(node.tag, node.tagToken.offset);
 }
 
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
   /**
    * The offset of the character immediately following the last character of this node's URI, may be
    * `-1` if synthetic.
    */
@@ skipping 25 matching lines @@
    * The prefix that was specified as part of the import directive, or `null` if there was no
    * prefix specified.
    */
   PrefixElement prefix;
 
   /**
    * Initialize a newly created import element.
    *
    * @param offset the directive offset, may be `-1` if synthetic.
    */
-  ImportElementImpl(int offset) : super.con2(null, offset);
+  ImportElementImpl(int offset) : super(null, offset);
 
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
 
   ElementKind get kind => ElementKind.IMPORT;
 
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(prefix, visitor);
   }
 
@@ skipping 26 matching lines @@
   static List<LabelElement> EMPTY_ARRAY = new List<LabelElement>(0);
 
   /**
    * Initialize a newly created label element to have the given name.
    *
    * @param name the name of this element
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
-  LabelElementImpl(Identifier name, bool onSwitchStatement, bool onSwitchMember) : super.con1(name) {
+  LabelElementImpl(Identifier name, bool onSwitchStatement, bool onSwitchMember) : super.forNode(name) {
     this._onSwitchStatement = onSwitchStatement;
     this._onSwitchMember = onSwitchMember;
   }
 
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 
   ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
 
   ElementKind get kind => ElementKind.LABEL;
 
@@ skipping 94 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.con1(name);
+  LibraryElementImpl(this.context, LibraryIdentifier name) : super.forNode(name);
 
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == (object as LibraryElementImpl).definingCompilationUnit;
 
   ElementImpl getChild(String identifier) {
     if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier == identifier) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
@@ skipping 902 matching lines @@
   /**
    * An empty array of prefix elements.
    */
   static List<PrefixElement> EMPTY_ARRAY = new List<PrefixElement>(0);
 
   /**
    * Initialize a newly created prefix element to have the given name.
    *
    * @param name the name of this element
    */
-  PrefixElementImpl(Identifier name) : super.con1(name);
+  PrefixElementImpl(Identifier name) : super.forNode(name);
 
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
 
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
 
   List<LibraryElement> get importedLibraries => _importedLibraries;
 
   ElementKind get kind => ElementKind.PREFIX;
 
   /**
@@ skipping 224 matching lines @@
  * Instances of the class `ToolkitObjectElementImpl` implement a `ToolkitObjectElement`.
  */
 abstract class ToolkitObjectElementImpl extends ElementImpl implements ToolkitObjectElement {
   /**
    * Initialize a newly created toolkit object 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
    */
-  ToolkitObjectElementImpl(String name, int nameOffset) : super.con2(name, nameOffset);
+  ToolkitObjectElementImpl(String name, int nameOffset) : super(name, nameOffset);
 }
 
 /**
  * Instances of the class `TopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement`.
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
    * An empty array of top-level variable elements.
    */
@@ skipping 38 matching lines @@
   /**
    * An empty array of type parameter elements.
    */
   static List<TypeParameterElement> EMPTY_ARRAY = new List<TypeParameterElement>(0);
 
   /**
    * Initialize a newly created type parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  TypeParameterElementImpl(Identifier name) : super.con1(name);
+  TypeParameterElementImpl(Identifier name) : super.forNode(name);
 
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
 
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   void appendTo(JavaStringBuilder builder) {
     builder.append(displayName);
     if (bound != null) {
       builder.append(" extends ");
       builder.append(bound);
@@ skipping 19 matching lines @@
   /**
    * An empty array of variable elements.
    */
   static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>(0);
 
   /**
    * Initialize a newly created variable element to have the given name.
    *
    * @param name the name of this element
    */
-  VariableElementImpl.con1(Identifier name) : super.con1(name);
+  VariableElementImpl.con1(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created variable 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
    */
-  VariableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
+  VariableElementImpl.con2(String name, int nameOffset) : super(name, nameOffset);
 
   /**
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or `null` if this variable is not a 'const' variable, if it does not have an
    * initializer, or if the compilation unit containing the variable has not been resolved.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
 
@@ skipping 3527 matching lines @@
   TypeParameterElement get element;
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }