Simplify constructors translation, improve code style.

pkg/analyzer_experimental/lib/src/generated/element.dart

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
 import 'sdk.dart' show DartSdk;
@@ skipping 1722 matching lines @@
   /**
    * An empty array of type 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.con1(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);
   }
   ElementImpl getChild(String identifier2) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (((accessor as PropertyAccessorElementImpl)).identifier == identifier2) {
@@ skipping 438 matching lines @@
    * The URI that is specified by the "part" directive in the enclosing library, or `null` if
    * this is the defining compilation unit of a library.
    */
   String _uri;
 
   /**
    * 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.con2(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;
   ElementImpl getChild(String identifier2) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (((accessor as PropertyAccessorElementImpl)).identifier == identifier2) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (VariableElement variable in _variables) {
@@ skipping 140 matching lines @@
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created field element to have the given name.
    *
    * @param name the name of this element
    */
-  ConstFieldElementImpl(Identifier name) : super.con1(name) {
-  }
+  ConstFieldElementImpl(Identifier name) : super.con1(name);
   EvaluationResultImpl get evaluationResult => _result;
   void set evaluationResult(EvaluationResultImpl result2) {
     this._result = result2;
   }
 }
 /**
  * Instances of the class `ConstLocalVariableElementImpl` implement a
  * `LocalVariableElement` for a local 'const' variable that has an initializer.
  *
  * @coverage dart.engine.element
  */
 class ConstLocalVariableElementImpl extends LocalVariableElementImpl {
 
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
-  ConstLocalVariableElementImpl(Identifier name) : super(name) {
-  }
+  ConstLocalVariableElementImpl(Identifier name) : super(name);
   EvaluationResultImpl get evaluationResult => _result;
   void set evaluationResult(EvaluationResultImpl result2) {
     this._result = result2;
   }
 }
 /**
  * Instances of the class `ConstTopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement` for a top-level 'const' variable that has an initializer.
  */
 class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl {
 
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
-  ConstTopLevelVariableElementImpl(Identifier name) : super.con1(name) {
-  }
+  ConstTopLevelVariableElementImpl(Identifier name) : super.con1(name);
   EvaluationResultImpl get evaluationResult => _result;
   void set evaluationResult(EvaluationResultImpl result2) {
     this._result = result2;
   }
 }
 /**
  * Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
  *
  * @coverage dart.engine.element
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
 
   /**
    * An empty array of constructor elements.
    */
   static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
 
   /**
    * The constructor to which this constructor is redirecting.
    */
   ConstructorElement _redirectedConstructor;
 
   /**
    * Initialize a newly created constructor element to have the given name.
    *
    * @param name the name of this element
    */
-  ConstructorElementImpl(Identifier name) : super.con1(name) {
-  }
+  ConstructorElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.CONSTRUCTOR;
   ConstructorElement get redirectedConstructor => _redirectedConstructor;
   bool get isConst => hasModifier(Modifier.CONST);
   bool get isDefaultConstructor {
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
@@ skipping 54 matching lines @@
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  DefaultFieldFormalParameterElementImpl(Identifier name) : super(name) {
-  }
+  DefaultFieldFormalParameterElementImpl(Identifier name) : super(name);
   EvaluationResultImpl get evaluationResult => _result;
   void set evaluationResult(EvaluationResultImpl result2) {
     this._result = result2;
   }
 }
 /**
  * Instances of the class `DefaultParameterElementImpl` implement a `ParameterElement`
  * for parameters that have an initializer.
  *
  * @coverage dart.engine.element
  */
 class DefaultParameterElementImpl extends ParameterElementImpl {
 
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  DefaultParameterElementImpl(Identifier name) : super.con1(name) {
-  }
+  DefaultParameterElementImpl(Identifier name) : super.con1(name);
   EvaluationResultImpl get evaluationResult => _result;
   void set evaluationResult(EvaluationResultImpl result2) {
     this._result = result2;
   }
 }
 /**
  * Instances of the class `DynamicElementImpl` represent the synthetic element representing
  * the declaration of the type `dynamic`.
  *
  * @coverage dart.engine.element
@@ skipping 106 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 name2) {
-    _jtd_constructor_197_impl(name2);
-  }
-  _jtd_constructor_197_impl(Identifier name2) {
-    _jtd_constructor_198_impl(name2 == null ? "" : name2.name, name2 == null ? -1 : name2.offset);
-  }
+  ElementImpl.con1(Identifier name) : this.con2(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 name2, int nameOffset2) {
-    _jtd_constructor_198_impl(name2, nameOffset2);
-  }
-  _jtd_constructor_198_impl(String name2, int nameOffset2) {
-    this._name = StringUtilities.intern(name2);
-    this._nameOffset = nameOffset2;
+  ElementImpl.con2(String name, int nameOffset) {
+    this._name = StringUtilities.intern(name);
+    this._nameOffset = nameOffset;
   }
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
   bool operator ==(Object object) => object != null && object.runtimeType == runtimeType && ((object as Element)).location == location;
   Element getAncestor(Type elementClass) {
@@ skipping 186 matching lines @@
    * The character used to separate components in the encoded form.
    */
   static int _SEPARATOR_CHAR = 0x3B;
 
   /**
    * Initialize a newly created location to represent the given element.
    *
    * @param element the element whose location is being represented
    */
   ElementLocationImpl.con1(Element element) {
-    _jtd_constructor_199_impl(element);
-  }
-  _jtd_constructor_199_impl(Element element) {
     List<String> components = new List<String>();
     Element ancestor = element;
     while (ancestor != null) {
       components.insert(0, ((ancestor as ElementImpl)).identifier);
       ancestor = ancestor.enclosingElement;
     }
     this._components = new List.from(components);
   }
 
   /**
    * Initialize a newly created location from the given encoded form.
    *
    * @param encoding the encoded form of a location
    */
   ElementLocationImpl.con2(String encoding) {
-    _jtd_constructor_200_impl(encoding);
-  }
-  _jtd_constructor_200_impl(String encoding) {
     this._components = decode(encoding);
   }
   bool operator ==(Object object) {
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     List<String> otherComponents = location._components;
     int length = _components.length;
     if (otherComponents.length != length) {
@@ skipping 114 matching lines @@
   /**
    * The library defined by the script tag's content.
    */
   LibraryElement _scriptLibrary;
 
   /**
    * 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`)
    */
-  EmbeddedHtmlScriptElementImpl(XmlTagNode node) : super(node) {
-  }
+  EmbeddedHtmlScriptElementImpl(XmlTagNode node) : super(node);
   accept(ElementVisitor visitor) => visitor.visitEmbeddedHtmlScriptElement(this);
   ElementKind get kind => ElementKind.EMBEDDED_HTML_SCRIPT;
   LibraryElement get scriptLibrary => _scriptLibrary;
 
   /**
    * Set the script library defined by the script tag's content.
    *
    * @param scriptLibrary the library or `null` if none
    */
   void set scriptLibrary(LibraryElementImpl scriptLibrary2) {
@@ skipping 45 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) {
-    _jtd_constructor_202_impl(name);
-  }
-  _jtd_constructor_202_impl(Identifier name) {
-  }
+  ExecutableElementImpl.con1(Identifier name) : super.con1(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) {
-    _jtd_constructor_203_impl(name, nameOffset);
-  }
-  _jtd_constructor_203_impl(String name, int nameOffset) {
-  }
+  ExecutableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
   ElementImpl getChild(String identifier2) {
     for (ExecutableElement function in _functions) {
       if (((function as ExecutableElementImpl)).identifier == identifier2) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
       if (((label as LabelElementImpl)).identifier == identifier2) {
         return label as LabelElementImpl;
       }
@@ skipping 125 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.con1(null);
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
   List<NamespaceCombinator> get combinators => _combinators;
   LibraryElement get exportedLibrary => _exportedLibrary;
   ElementKind get kind => ElementKind.EXPORT;
   String get uri => _uri;
 
   /**
    * Set the combinators that were specified as part of the export directive to the given array of
    * combinators.
    *
@@ skipping 38 matching lines @@
   /**
    * The source specified in the `source` attribute or `null` if unspecified.
    */
   Source _scriptSource;
 
   /**
    * 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`)
    */
-  ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node) {
-  }
+  ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
   accept(ElementVisitor visitor) => visitor.visitExternalHtmlScriptElement(this);
   ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
   Source get scriptSource => _scriptSource;
 
   /**
    * Set the source specified in the `source` attribute.
    *
    * @param scriptSource the script source or `null` if unspecified
    */
   void set scriptSource(Source scriptSource2) {
@@ skipping 10 matching lines @@
   /**
    * An empty array of field elements.
    */
   static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
 
   /**
    * Initialize a newly created field element to have the given name.
    *
    * @param name the name of this element
    */
-  FieldElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_206_impl(name);
-  }
-  _jtd_constructor_206_impl(Identifier name) {
-  }
+  FieldElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created synthetic field element to have the given name.
    *
    * @param name the name of this element
    */
-  FieldElementImpl.con2(String name) : super.con2(name) {
-    _jtd_constructor_207_impl(name);
-  }
-  _jtd_constructor_207_impl(String name) {
-  }
+  FieldElementImpl.con2(String name) : super.con2(name);
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.FIELD;
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this field is static to correspond to the given value.
    *
    * @param isStatic `true` if the field is static
    */
@@ skipping 13 matching lines @@
   /**
    * The field associated with this field formal parameter.
    */
   FieldElement _field;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  FieldFormalParameterElementImpl(Identifier name) : super.con1(name) {
-  }
+  FieldFormalParameterElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
   FieldElement get field => _field;
   bool get isInitializingFormal => true;
 
   /**
    * Set the field element associated with this field formal parameter to the given element.
    *
    * @param field the new field element
    */
   void set field(FieldElement field2) {
@@ skipping 20 matching lines @@
 
   /**
    * An empty array of function elements.
    */
   static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
 
   /**
    * Initialize a newly created synthetic function element.
    */
   FunctionElementImpl() : super.con2("", -1) {
-    _jtd_constructor_209_impl();
-  }
-  _jtd_constructor_209_impl() {
     synthetic = true;
   }
 
   /**
    * Initialize a newly created function element to have the given name.
    *
    * @param name the name of this element
    */
-  FunctionElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_210_impl(name);
-  }
-  _jtd_constructor_210_impl(Identifier name) {
-  }
+  FunctionElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created function element to have no name and the given offset. This is used
    * for function expressions, which have no name.
    *
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
-  FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset) {
-    _jtd_constructor_211_impl(nameOffset);
-  }
-  _jtd_constructor_211_impl(int nameOffset) {
-  }
+  FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset);
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
   String get identifier => "${name}@${nameOffset}";
   ElementKind get kind => ElementKind.FUNCTION;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
   bool get isStatic => enclosingElement is CompilationUnitElement;
@@ skipping 49 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.con1(name);
   accept(ElementVisitor visitor) => visitor.visitFunctionTypeAliasElement(this);
   ElementImpl getChild(String identifier2) {
     for (VariableElement parameter in _parameters) {
       if (((parameter as VariableElementImpl)).identifier == identifier2) {
         return parameter as VariableElementImpl;
       }
     }
     for (TypeVariableElement typeVariable in _typeVariables) {
       if (((typeVariable as TypeVariableElementImpl)).identifier == identifier2) {
         return typeVariable as TypeVariableElementImpl;
@@ skipping 211 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.lexeme, node.tag.offset) {
-  }
+  HtmlScriptElementImpl(XmlTagNode node) : super.con2(node.tag.lexeme, node.tag.offset);
 }
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
  *
  * @coverage dart.engine.element
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
 
   /**
    * The URI that is specified by this directive.
@@ skipping 13 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.
    */
-  ImportElementImpl() : super.con1(null) {
-  }
+  ImportElementImpl() : super.con1(null);
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
   List<NamespaceCombinator> get combinators => _combinators;
   LibraryElement get importedLibrary => _importedLibrary;
   ElementKind get kind => ElementKind.IMPORT;
   PrefixElement get prefix => _prefix;
   String get uri => _uri;
 
   /**
    * Set the combinators that were specified as part of the import directive to the given array of
    * combinators.
@@ skipping 385 matching lines @@
   /**
    * An empty array of field elements.
    */
   static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
-  LocalVariableElementImpl(Identifier name) : super.con1(name) {
-  }
+  LocalVariableElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   /**
@@ skipping 25 matching lines @@
   /**
    * An empty array of method elements.
    */
   static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
 
   /**
    * Initialize a newly created method element to have the given name.
    *
    * @param name the name of this element
    */
-  MethodElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_220_impl(name);
-  }
-  _jtd_constructor_220_impl(Identifier name) {
-  }
+  MethodElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created method 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
    */
-  MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
-    _jtd_constructor_221_impl(name, nameOffset);
-  }
-  _jtd_constructor_221_impl(String name, int nameOffset) {
-  }
+  MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.METHOD;
   String get name {
     String name = super.name;
     if (isOperator && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
@@ skipping 52 matching lines @@
   static final Modifier STATIC = new Modifier('STATIC', 8);
   static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 9);
   static final Modifier TYPEDEF = new Modifier('TYPEDEF', 10);
   static final List<Modifier> values = [ABSTRACT, CONST, FACTORY, FINAL, GETTER, MIXIN, REFERENCES_SUPER, SETTER, STATIC, SYNTHETIC, TYPEDEF];
 
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
-  Modifier(this.name, this.ordinal) {
-  }
+  Modifier(this.name, this.ordinal);
   int compareTo(Modifier other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 /**
  * Instances of the class `MultiplyDefinedElementImpl` represent a collection of elements that
  * have the same name within the same scope.
  *
  * @coverage dart.engine.element
  */
@@ skipping 140 matching lines @@
   /**
    * An empty array of field elements.
    */
   static List<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>(0);
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  ParameterElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_224_impl(name);
-  }
-  _jtd_constructor_224_impl(Identifier name) {
-  }
+  ParameterElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created parameter 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
    */
-  ParameterElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
-    _jtd_constructor_225_impl(name, nameOffset);
-  }
-  _jtd_constructor_225_impl(String name, int nameOffset) {
-  }
+  ParameterElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
   SourceRange get defaultValueRange {
     if (_defaultValueRangeLength < 0) {
       return null;
     }
     return new SourceRange(_defaultValueRangeOffset, _defaultValueRangeLength);
   }
   ElementKind get kind => ElementKind.PARAMETER;
   ParameterKind get parameterKind => _parameterKind;
   List<ParameterElement> get parameters => _parameters;
@@ skipping 90 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.con1(name);
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<LibraryElement> get importedLibraries => _importedLibraries;
   ElementKind get kind => ElementKind.PREFIX;
 
   /**
    * Set the libraries that are imported using this prefix to the given libraries.
    *
    * @param importedLibraries the libraries that are imported using this prefix
    */
@@ skipping 24 matching lines @@
   /**
    * An empty array of property accessor elements.
    */
   static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>(0);
 
   /**
    * Initialize a newly created property accessor element to have the given name.
    *
    * @param name the name of this element
    */
-  PropertyAccessorElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_227_impl(name);
-  }
-  _jtd_constructor_227_impl(Identifier name) {
-  }
+  PropertyAccessorElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created synthetic property accessor element to be associated with the given
    * variable.
    *
    * @param variable the variable with which this access is associated
    */
-  PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable2) : super.con2(variable2.name, variable2.nameOffset) {
-    _jtd_constructor_228_impl(variable2);
-  }
-  _jtd_constructor_228_impl(PropertyInducingElementImpl variable2) {
-    this._variable = variable2;
+  PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable) : super.con2(variable.name, variable.nameOffset) {
+    this._variable = variable;
     synthetic = true;
   }
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
   bool operator ==(Object object) => super == object && identical(isGetter, ((object as PropertyAccessorElement)).isGetter);
   PropertyAccessorElement get correspondingGetter {
     if (isGetter || _variable == null) {
       return null;
     }
     return _variable.getter;
   }
@@ skipping 93 matching lines @@
   /**
    * An empty array of elements.
    */
   static List<PropertyInducingElement> EMPTY_ARRAY = new List<PropertyInducingElement>(0);
 
   /**
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    */
-  PropertyInducingElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_229_impl(name);
-  }
-  _jtd_constructor_229_impl(Identifier name) {
-  }
+  PropertyInducingElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created synthetic element to have the given name.
    *
    * @param name the name of this element
    */
   PropertyInducingElementImpl.con2(String name) : super.con2(name, -1) {
-    _jtd_constructor_230_impl(name);
-  }
-  _jtd_constructor_230_impl(String name) {
     synthetic = true;
   }
   PropertyAccessorElement get getter => _getter;
   PropertyAccessorElement get setter => _setter;
 
   /**
    * Set the getter associated with this element to the given accessor.
    *
    * @param getter the getter associated with this element
    */
@@ skipping 58 matching lines @@
   /**
    * An empty array of top-level variable elements.
    */
   static List<TopLevelVariableElement> EMPTY_ARRAY = new List<TopLevelVariableElement>(0);
 
   /**
    * Initialize a newly created top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
-  TopLevelVariableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_232_impl(name);
-  }
-  _jtd_constructor_232_impl(Identifier name) {
-  }
+  TopLevelVariableElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
-  TopLevelVariableElementImpl.con2(String name) : super.con2(name) {
-    _jtd_constructor_233_impl(name);
-  }
-  _jtd_constructor_233_impl(String name) {
-  }
+  TopLevelVariableElementImpl.con2(String name) : super.con2(name);
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
   bool get isStatic => true;
 }
 /**
  * Instances of the class `TypeVariableElementImpl` implement a `TypeVariableElement`.
  *
  * @coverage dart.engine.element
  */
 class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
@@ skipping 12 matching lines @@
   /**
    * An empty array of type variable elements.
    */
   static List<TypeVariableElement> EMPTY_ARRAY = new List<TypeVariableElement>(0);
 
   /**
    * Initialize a newly created type variable element to have the given name.
    *
    * @param name the name of this element
    */
-  TypeVariableElementImpl(Identifier name) : super.con1(name) {
-  }
+  TypeVariableElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(this);
   Type2 get bound => _bound;
   ElementKind get kind => ElementKind.TYPE_VARIABLE;
   TypeVariableType get type => _type;
 
   /**
    * Set the type representing the bound associated with this variable to the given type.
    *
    * @param bound the type representing the bound associated with this variable
    */
@@ skipping 38 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) {
-    _jtd_constructor_235_impl(name);
-  }
-  _jtd_constructor_235_impl(Identifier name) {
-  }
+  VariableElementImpl.con1(Identifier name) : super.con1(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) {
-    _jtd_constructor_236_impl(name, nameOffset);
-  }
-  _jtd_constructor_236_impl(String name, int nameOffset) {
-  }
+  VariableElementImpl.con2(String name, int nameOffset) : super.con2(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 or does not have an
    * initializer.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
   FunctionElement get initializer => _initializer;
@@ skipping 89 matching lines @@
     }
     return new ConstructorMember(baseConstructor, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a constructor of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  ConstructorMember(ConstructorElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
-  }
+  ConstructorMember(ConstructorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
   ConstructorElement get baseElement => super.baseElement as ConstructorElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   ConstructorElement get redirectedConstructor => from(baseElement.redirectedConstructor, definingType);
   bool get isConst => baseElement.isConst;
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
   bool get isFactory => baseElement.isFactory;
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
@@ skipping 29 matching lines @@
  */
 abstract class ExecutableMember extends Member implements ExecutableElement {
 
   /**
    * Initialize a newly created element to represent an executable element of the given
    * parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  ExecutableMember(ExecutableElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
-  }
+  ExecutableMember(ExecutableElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
   ExecutableElement get baseElement => super.baseElement as ExecutableElement;
   List<FunctionElement> get functions {
     throw new UnsupportedOperationException();
   }
   List<LabelElement> get labels => baseElement.labels;
   List<LocalVariableElement> get localVariables {
     throw new UnsupportedOperationException();
   }
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
@@ skipping 52 matching lines @@
     }
     return new FieldMember(baseField, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a field of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  FieldMember(FieldElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
-  }
+  FieldMember(FieldElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
   FieldElement get baseElement => super.baseElement as FieldElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   PropertyAccessorElement get getter => PropertyAccessorMember.from(baseElement.getter, definingType);
   PropertyAccessorElement get setter => PropertyAccessorMember.from(baseElement.setter, definingType);
   bool get isStatic => baseElement.isStatic;
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 /**
  * The abstract class `Member` defines the behavior common to elements that represent members
@@ skipping 136 matching lines @@
     }
     return new MethodMember(baseMethod, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a method of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  MethodMember(MethodElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
-  }
+  MethodMember(MethodElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   MethodElement get baseElement => super.baseElement as MethodElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   bool get isAbstract => baseElement.isAbstract;
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement.enclosingElement.displayName);
@@ skipping 45 matching lines @@
     }
     return new ParameterMember(baseParameter, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType) {
-  }
+  ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
   Element getAncestor(Type elementClass) {
     Element element = baseElement.getAncestor(elementClass);
     ParameterizedType definingType = this.definingType;
     if (definingType is InterfaceType) {
       InterfaceType definingInterfaceType = definingType as InterfaceType;
       if (element is ConstructorElement) {
         return ConstructorMember.from((element as ConstructorElement), definingInterfaceType) as Element;
       } else if (element is MethodElement) {
         return MethodMember.from((element as MethodElement), definingInterfaceType) as Element;
@@ skipping 79 matching lines @@
     return new PropertyAccessorMember(baseAccessor, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a property accessor of the given parameterized
    * type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  PropertyAccessorMember(PropertyAccessorElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
-  }
+  PropertyAccessorMember(PropertyAccessorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
   PropertyAccessorElement get baseElement => super.baseElement as PropertyAccessorElement;
   PropertyAccessorElement get correspondingGetter => from(baseElement.correspondingGetter, definingType);
   PropertyAccessorElement get correspondingSetter => from(baseElement.correspondingSetter, definingType);
   Element get enclosingElement => baseElement.enclosingElement;
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
       return FieldMember.from(((variable as FieldElement)), definingType);
     }
@@ skipping 11 matching lines @@
  */
 abstract class VariableMember extends Member implements VariableElement {
 
   /**
    * Initialize a newly created element to represent an executable element of the given
    * parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  VariableMember(VariableElement baseElement, ParameterizedType definingType) : super(baseElement, definingType) {
-  }
+  VariableMember(VariableElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
   VariableElement get baseElement => super.baseElement as VariableElement;
   FunctionElement get initializer {
     throw new UnsupportedOperationException();
   }
   Type2 get type => substituteFor(baseElement.type);
   bool get isConst => baseElement.isConst;
   bool get isFinal => baseElement.isFinal;
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
@@ skipping 14 matching lines @@
   /**
    * Return the unique instance of this class.
    *
    * @return the unique instance of this class
    */
   static BottomTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
-  BottomTypeImpl() : super(null, "<bottom>") {
-  }
+  BottomTypeImpl() : super(null, "<bottom>");
   bool operator ==(Object object) => identical(object, this);
   bool isMoreSpecificThan(Type2 type) => true;
   bool isSubtypeOf(Type2 type) => true;
   bool isSupertypeOf(Type2 type) => false;
   BottomTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
  *
  * @coverage dart.engine.type
@@ skipping 71 matching lines @@
    * An array containing the actual types of the type arguments.
    */
   List<Type2> _typeArguments = TypeImpl.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
-  FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name) {
-    _jtd_constructor_302_impl(element);
-  }
-  _jtd_constructor_302_impl(ExecutableElement element) {
-  }
+  FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name);
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
-  FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name) {
-    _jtd_constructor_303_impl(element);
-  }
-  _jtd_constructor_303_impl(FunctionTypeAliasElement element) {
-  }
+  FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name);
   bool operator ==(Object object) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     return element == otherType.element && JavaArrays.equals(normalParameterTypes, otherType.normalParameterTypes) && JavaArrays.equals(optionalParameterTypes, otherType.optionalParameterTypes) && equals2(namedParameterTypes, otherType.namedParameterTypes) && returnType == otherType.returnType;
   }
   String get displayName {
     String name = this.name;
     if (name == null) {
@@ skipping 497 matching lines @@
   /**
    * An array containing the actual types of the type arguments.
    */
   List<Type2> _typeArguments = TypeImpl.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created type to be declared by the given element.
    *
    * @param element the element representing the declaration of the type
    */
-  InterfaceTypeImpl.con1(ClassElement element) : super(element, element.displayName) {
-    _jtd_constructor_304_impl(element);
-  }
-  _jtd_constructor_304_impl(ClassElement element) {
-  }
+  InterfaceTypeImpl.con1(ClassElement element) : super(element, element.displayName);
 
   /**
    * Initialize a newly created type to have the given name. This constructor should only be used in
    * cases where there is no declaration of the type.
    *
    * @param name the name of the type
    */
-  InterfaceTypeImpl.con2(String name) : super(null, name) {
-    _jtd_constructor_305_impl(name);
-  }
-  _jtd_constructor_305_impl(String name) {
-  }
+  InterfaceTypeImpl.con2(String name) : super(null, name);
   bool operator ==(Object object) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return element == otherType.element && JavaArrays.equals(_typeArguments, otherType._typeArguments);
   }
   List<PropertyAccessorElement> get accessors {
     List<PropertyAccessorElement> accessors = element.accessors;
     List<PropertyAccessorElement> members = new List<PropertyAccessorElement>(accessors.length);
@@ skipping 513 matching lines @@
     }
     return types;
   }
 
   /**
    * Initialize a newly created type variable to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the type variable
    */
-  TypeVariableTypeImpl(TypeVariableElement element) : super(element, element.name) {
-  }
+  TypeVariableTypeImpl(TypeVariableElement element) : super(element, element.name);
   bool operator ==(Object object) => object is TypeVariableTypeImpl && element == ((object as TypeVariableTypeImpl)).element;
   TypeVariableElement get element => super.element as TypeVariableElement;
   int get hashCode => element.hashCode;
   bool isMoreSpecificThan(Type2 type) {
     Type2 upperBound = element.bound;
     return type == upperBound;
   }
   bool isSubtypeOf(Type2 type) => true;
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length = parameterTypes.length;
@@ skipping 20 matching lines @@
   /**
    * Return the unique instance of this class.
    *
    * @return the unique instance of this class
    */
   static VoidTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
-  VoidTypeImpl() : super(null, Keyword.VOID.syntax) {
-  }
+  VoidTypeImpl() : super(null, Keyword.VOID.syntax);
   bool operator ==(Object object) => identical(object, this);
   bool isSubtypeOf(Type2 type) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
   bool get isVoid => true;
   VoidTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * The interface `FunctionType` defines the behavior common to objects representing the type
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * * The types of functions that only have required parameters. These have the general form
@@ skipping 590 matching lines @@
 }
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  *
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }