Generate unique names less aggressively.

pkg/analyzer_experimental/lib/src/generated/html.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.html;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
@@ skipping 36 matching lines @@
   }
   _jtd_constructor_150_impl(TokenType type, int offset) {
     _jtd_constructor_151_impl(type, offset, type.lexeme);
   }
   /**
    * Initialize a newly created token.
    * @param type the token type (not {@code null})
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param value the lexeme represented by this token (not {@code null})
    */
-  Token.con2(TokenType type4, int offset3, String value7) {
-    _jtd_constructor_151_impl(type4, offset3, value7);
+  Token.con2(TokenType type2, int offset2, String value2) {
+    _jtd_constructor_151_impl(type2, offset2, value2);
   }
-  _jtd_constructor_151_impl(TokenType type4, int offset3, String value7) {
-    this._type = type4;
-    this._value = StringUtilities.intern(value7);
-    this._offset = offset3;
+  _jtd_constructor_151_impl(TokenType type2, int offset2, String value2) {
+    this._type = type2;
+    this._value = StringUtilities.intern(value2);
+    this._offset = offset2;
   }
   /**
    * Return the offset from the beginning of the file to the character after last character of the
    * token.
    * @return the offset from the beginning of the file to the first character after last character
    * of the token
    */
   int get end => _offset + length;
   /**
    * Return the number of characters in the node's source range.
@@ skipping 124 matching lines @@
   /**
    * Return the last token included in this node's source range.
    * @return the last token or {@code null} if none
    */
   Token get endToken;
   /**
    * Return the number of characters in the node's source range.
    * @return the number of characters in the node's source range
    */
   int get length {
-    Token beginToken4 = beginToken;
-    Token endToken4 = endToken;
-    if (beginToken4 == null || endToken4 == null) {
+    Token beginToken2 = beginToken;
+    Token endToken2 = endToken;
+    if (beginToken2 == null || endToken2 == null) {
       return -1;
     }
-    return endToken4.offset + endToken4.length - beginToken4.offset;
+    return endToken2.offset + endToken2.length - beginToken2.offset;
   }
   /**
    * Return the offset from the beginning of the file to the first character in the node's source
    * range.
    * @return the offset from the beginning of the file to the first character in the node's source
    * range
    */
   int get offset {
-    Token beginToken5 = beginToken;
-    if (beginToken5 == null) {
+    Token beginToken2 = beginToken;
+    if (beginToken2 == null) {
       return -1;
     }
     return beginToken.offset;
   }
   /**
    * Return this node's parent node, or {@code null} if this node is the root of an AST structure.
    * <p>
    * Note that the relationship between an AST node and its parent node may change over the lifetime
    * of a node.
    * @return the parent of this node, or {@code null} if none
@@ skipping 375 matching lines @@
    * Initialize a newly created scanner to scan the characters in the given string.
    * @param source the source being scanned
    * @param string the string from which characters will be read
    */
   StringScanner(Source source, String string) : super(source) {
     this._string = string;
     this._stringLength = string.length;
     this._charOffset = -1;
   }
   int get offset => _charOffset;
-  void set offset(int offset12) {
-    _charOffset = offset12;
+  void set offset(int offset2) {
+    _charOffset = offset2;
   }
   int advance() {
     if (++_charOffset < _stringLength) {
       return _string.codeUnitAt(_charOffset);
     }
     _charOffset = _stringLength;
     return -1;
   }
   String getString(int start, int endDelta) => _string.substring(start, _charOffset + 1 + endDelta);
   int peek() {
@@ skipping 65 matching lines @@
   ToSourceVisitor(PrintWriter writer) {
     this._writer = writer;
   }
   Object visitHtmlUnit(HtmlUnit node) {
     for (XmlTagNode child in node.tagNodes) {
       visit(child);
     }
     return null;
   }
   Object visitXmlAttributeNode(XmlAttributeNode node) {
-    String name11 = node.name.lexeme;
-    Token value9 = node.value;
-    if (name11.length == 0) {
+    String name2 = node.name.lexeme;
+    Token value2 = node.value;
+    if (name2.length == 0) {
       _writer.print("__");
     } else {
-      _writer.print(name11);
+      _writer.print(name2);
     }
     _writer.print("=");
-    if (value9 == null) {
+    if (value2 == null) {
       _writer.print("__");
     } else {
-      _writer.print(value9.lexeme);
+      _writer.print(value2.lexeme);
     }
     return null;
   }
   Object visitXmlTagNode(XmlTagNode node) {
     _writer.print("<");
     String tagName = node.tag.lexeme;
     _writer.print(tagName);
     for (XmlAttributeNode attribute in node.attributes) {
       _writer.print(" ");
       visit(attribute);
@@ skipping 177 matching lines @@
    */
   HtmlScanner(Source source) {
     this._source = source;
   }
   void accept(CharBuffer contents, int modificationTime2) {
     this._modificationTime = modificationTime2;
     _scanner = new CharBufferScanner(_source, contents);
     _scanner.passThroughElements = _SCRIPT_TAG;
     _token = _scanner.tokenize();
   }
-  void accept2(String contents, int modificationTime3) {
-    this._modificationTime = modificationTime3;
+  void accept2(String contents, int modificationTime2) {
+    this._modificationTime = modificationTime2;
     _scanner = new StringScanner(_source, contents);
     _scanner.passThroughElements = _SCRIPT_TAG;
     _token = _scanner.tokenize();
   }
   /**
    * Answer the result of scanning the source
    * @return the result (not {@code null})
    */
   HtmlScanResult get result => new HtmlScanResult(_modificationTime, _token, _scanner.lineStarts);
 }
@@ skipping 95 matching lines @@
       value = insertSyntheticToken(TokenType.STRING);
     }
     return new XmlAttributeNode(name, equals, value);
   }
   /**
    * Parse the stream for a sequence of attributes. This method advances the current token to the
    * next {@link TokenType#GT}, {@link TokenType#SLASH_GT}, or {@link TokenType#EOF}.
    * @return a collection of zero or more attributes (not {@code null}, contains no {@code null}s)
    */
   List<XmlAttributeNode> parseAttributes() {
-    TokenType type11 = _currentToken.type;
-    if (identical(type11, TokenType.GT) || identical(type11, TokenType.SLASH_GT) || identical(type11, TokenType.EOF)) {
+    TokenType type2 = _currentToken.type;
+    if (identical(type2, TokenType.GT) || identical(type2, TokenType.SLASH_GT) || identical(type2, TokenType.EOF)) {
       return XmlTagNode.NO_ATTRIBUTES;
     }
     List<XmlAttributeNode> attributes = new List<XmlAttributeNode>();
     while (true) {
       while (true) {
         if (_currentToken.type == TokenType.GT || _currentToken.type == TokenType.SLASH_GT || _currentToken.type == TokenType.EOF) {
           return attributes;
         } else if (_currentToken.type == TokenType.TAG) {
           attributes.add(parseAttribute());
         } else {
           reportUnexpectedToken();
           _currentToken = _currentToken.next;
         }
         break;
       }
     }
   }
   /**
    * Parse the stream for a sequence of tag nodes existing within a parent tag node. This method
    * advances the current token to the next {@link TokenType#LT_SLASH} or {@link TokenType#EOF}.
    * @return a list of nodes (not {@code null}, contains no {@code null}s)
    */
   List<XmlTagNode> parseChildTagNodes() {
-    TokenType type12 = _currentToken.type;
-    if (identical(type12, TokenType.LT_SLASH) || identical(type12, TokenType.EOF)) {
+    TokenType type2 = _currentToken.type;
+    if (identical(type2, TokenType.LT_SLASH) || identical(type2, TokenType.EOF)) {
       return XmlTagNode.NO_TAG_NODES;
     }
     List<XmlTagNode> nodes = new List<XmlTagNode>();
     while (true) {
       while (true) {
         if (_currentToken.type == TokenType.LT) {
           nodes.add(parseTagNode());
         } else if (_currentToken.type == TokenType.LT_SLASH || _currentToken.type == TokenType.EOF) {
           return nodes;
         } else if (_currentToken.type == TokenType.COMMENT) {
@@ skipping 348 matching lines @@
   /**
    * Answer the tag nodes contained in the receiver. Callers should not manipulate the returned list
    * to edit the AST structure.
    * @return the children (not {@code null}, contains no {@code null}s)
    */
   List<XmlTagNode> get tagNodes => _tagNodes;
   /**
    * Set the element associated with this HTML unit.
    * @param element the element
    */
-  void set element(HtmlElementImpl element18) {
-    this._element = element18;
+  void set element(HtmlElementImpl element2) {
+    this._element = element2;
   }
   void visitChildren(XmlVisitor<Object> visitor) {
     for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 }