Translate private Java members to private Dart members.

pkg/analyzer/lib/src/generated/html.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.html;
 
 import 'dart:collection';
@@ skipping 270 matching lines @@
     } on HtmlUnitUtils_FoundTagNodeError catch (e) {
       return result[0];
     }
     return null;
   }
 
   /**
    * Returns the [Expression] that is part of the given root [AstNode] and encloses the
    * given offset.
    */
-  static Expression getExpressionAt(AstNode root, int offset) {
+  static Expression _getExpressionAt(AstNode root, int offset) {
     if (root.offset <= offset && offset < root.end) {
       AstNode dartNode = new NodeLocator.con1(offset).searchWithin(root);
       if (dartNode is Expression) {
         return dartNode;
       }
     }
     return null;
   }
 }
 
@@ skipping 24 matching lines @@
 }
 
 class ExpressionVisitor_HtmlUnitUtils_getExpression extends ExpressionVisitor {
   int offset = 0;
 
   List<Expression> result;
 
   ExpressionVisitor_HtmlUnitUtils_getExpression(this.offset, this.result) : super();
 
   void visitExpression(Expression expression) {
-    Expression at = HtmlUnitUtils.getExpressionAt(expression, offset);
+    Expression at = HtmlUnitUtils._getExpressionAt(expression, offset);
     if (at != null) {
       result[0] = at;
       throw new HtmlUnitUtils_FoundExpressionError();
     }
   }
 }
 
 class RecursiveXmlVisitor_HtmlUnitUtils_getTagNode extends RecursiveXmlVisitor<Object> {
   int offset = 0;
 
@@ skipping 204 matching lines @@
       }
       // This will create ArrayList for exactly given number of elements.
       return new List.from(children);
     }
     return children;
   }
 
   /**
    * This method exists for debugging purposes only.
    */
-  void appendIdentifier(JavaStringBuilder builder, XmlNode node) {
+  void _appendIdentifier(JavaStringBuilder builder, XmlNode node) {
     if (node is XmlTagNode) {
       builder.append(node.tag);
     } else if (node is XmlAttributeNode) {
       builder.append(node.name);
     } else {
       builder.append("htmlUnit");
     }
   }
 
   /**
    * This method exists for debugging purposes only.
    */
-  String buildRecursiveStructureMessage(XmlNode newParent) {
+  String _buildRecursiveStructureMessage(XmlNode newParent) {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("Attempt to create recursive structure: ");
     XmlNode current = newParent;
     while (current != null) {
       if (current != newParent) {
         builder.append(" -> ");
       }
       if (identical(current, this)) {
         builder.appendChar(0x2A);
-        appendIdentifier(builder, current);
+        _appendIdentifier(builder, current);
         builder.appendChar(0x2A);
       } else {
-        appendIdentifier(builder, current);
+        _appendIdentifier(builder, current);
       }
       current = current.parent;
     }
     return builder.toString();
   }
 
   /**
    * Set the parent of this node to the given node.
    *
    * @param newParent the node that is to be made the parent of this node
    */
   void set parent(XmlNode newParent) {
     XmlNode current = newParent;
     while (current != null) {
       if (identical(current, this)) {
-        AnalysisEngine.instance.logger.logError2("Circular structure while setting an XML node's parent", new IllegalArgumentException(buildRecursiveStructureMessage(newParent)));
+        AnalysisEngine.instance.logger.logError2("Circular structure while setting an XML node's parent", new IllegalArgumentException(_buildRecursiveStructureMessage(newParent)));
         return;
       }
       current = current.parent;
     }
     _parent = newParent;
   }
 }
 
 /**
  * Instances of the class `SimpleXmlVisitor` implement an AST visitor that will do nothing
@@ skipping 77 matching lines @@
   void set passThroughElements(List<String> passThroughElements) {
     this._passThroughElements = passThroughElements != null ? passThroughElements : _NO_PASS_THROUGH_ELEMENTS;
   }
 
   /**
    * Scan the source code to produce a list of tokens representing the source.
    *
    * @return the first token in the list of tokens that were produced
    */
   Token tokenize() {
-    scan();
-    appendEofToken();
-    return firstToken();
+    _scan();
+    _appendEofToken();
+    return _firstToken();
   }
 
   /**
    * Advance the current position and return the character at the new current position.
    *
    * @return the character at the new current position
    */
   int advance();
 
   /**
@@ skipping 15 matching lines @@
    */
   int peek();
 
   /**
    * Record the fact that we are at the beginning of a new line in the source.
    */
   void recordStartOfLine() {
     _lineStarts.add(offset);
   }
 
-  void appendEofToken() {
+  void _appendEofToken() {
     Token eofToken = new Token.con1(TokenType.EOF, offset);
     // The EOF token points to itself so that there is always infinite look-ahead.
     eofToken.setNext(eofToken);
     _tail = _tail.setNext(eofToken);
   }
 
-  Token emit(Token token) {
+  Token _emit(Token token) {
     _tail.setNext(token);
     _tail = token;
     return token;
   }
 
-  Token emitWithOffset(TokenType type, int start) => emit(new Token.con1(type, start));
+  Token _emitWithOffset(TokenType type, int start) => _emit(new Token.con1(type, start));
 
-  Token emitWithOffsetAndLength(TokenType type, int start, int count) => emit(new Token.con2(type, start, getString(start, count)));
+  Token _emitWithOffsetAndLength(TokenType type, int start, int count) => _emit(new Token.con2(type, start, getString(start, count)));
 
-  Token firstToken() => _tokens.next;
+  Token _firstToken() => _tokens.next;
 
-  int recordStartOfLineAndAdvance(int c) {
+  int _recordStartOfLineAndAdvance(int c) {
     if (c == 0xD) {
       c = advance();
       if (c == 0xA) {
         c = advance();
       }
       recordStartOfLine();
     } else if (c == 0xA) {
       c = advance();
       recordStartOfLine();
     } else {
       c = advance();
     }
     return c;
   }
 
-  void scan() {
+  void _scan() {
     bool inBrackets = false;
     String endPassThrough = null;
     int c = advance();
     while (c >= 0) {
       int start = offset;
       if (c == 0x3C) {
         c = advance();
         if (c == 0x21) {
           c = advance();
           if (c == 0x2D && peek() == 0x2D) {
             // handle a comment
             c = advance();
             int dashCount = 1;
             while (c >= 0) {
               if (c == 0x2D) {
                 dashCount++;
               } else if (c == 0x3E && dashCount >= 2) {
                 c = advance();
                 break;
               } else {
                 dashCount = 0;
               }
-              c = recordStartOfLineAndAdvance(c);
+              c = _recordStartOfLineAndAdvance(c);
             }
-            emitWithOffsetAndLength(TokenType.COMMENT, start, -1);
+            _emitWithOffsetAndLength(TokenType.COMMENT, start, -1);
             // Capture <!--> and <!---> as tokens but report an error
             if (_tail.length < 7) {
             }
           } else {
             // handle a declaration
             while (c >= 0) {
               if (c == 0x3E) {
                 c = advance();
                 break;
               }
-              c = recordStartOfLineAndAdvance(c);
+              c = _recordStartOfLineAndAdvance(c);
             }
-            emitWithOffsetAndLength(TokenType.DECLARATION, start, -1);
+            _emitWithOffsetAndLength(TokenType.DECLARATION, start, -1);
             if (!StringUtilities.endsWithChar(_tail.lexeme, 0x3E)) {
             }
           }
         } else if (c == 0x3F) {
           // handle a directive
           while (c >= 0) {
             if (c == 0x3F) {
               c = advance();
               if (c == 0x3E) {
                 c = advance();
                 break;
               }
             } else {
-              c = recordStartOfLineAndAdvance(c);
+              c = _recordStartOfLineAndAdvance(c);
             }
           }
-          emitWithOffsetAndLength(TokenType.DIRECTIVE, start, -1);
+          _emitWithOffsetAndLength(TokenType.DIRECTIVE, start, -1);
           if (_tail.length < 4) {
           }
         } else if (c == 0x2F) {
-          emitWithOffset(TokenType.LT_SLASH, start);
+          _emitWithOffset(TokenType.LT_SLASH, start);
           inBrackets = true;
           c = advance();
         } else {
           inBrackets = true;
-          emitWithOffset(TokenType.LT, start);
+          _emitWithOffset(TokenType.LT, start);
           // ignore whitespace in braces
           while (Character.isWhitespace(c)) {
-            c = recordStartOfLineAndAdvance(c);
+            c = _recordStartOfLineAndAdvance(c);
           }
           // get tag
           if (Character.isLetterOrDigit(c)) {
             int tagStart = offset;
             c = advance();
             while (Character.isLetterOrDigit(c) || c == 0x2D || c == 0x5F) {
               c = advance();
             }
-            emitWithOffsetAndLength(TokenType.TAG, tagStart, -1);
+            _emitWithOffsetAndLength(TokenType.TAG, tagStart, -1);
             // check tag against passThrough elements
             String tag = _tail.lexeme;
             for (String str in _passThroughElements) {
               if (str == tag) {
                 endPassThrough = "</${str}>";
                 break;
               }
             }
           }
         }
       } else if (c == 0x3E) {
-        emitWithOffset(TokenType.GT, start);
+        _emitWithOffset(TokenType.GT, start);
         inBrackets = false;
         c = advance();
         // if passThrough != null, read until we match it
         if (endPassThrough != null) {
           bool endFound = false;
           int len = endPassThrough.length;
           int firstC = endPassThrough.codeUnitAt(0);
           int index = 0;
           int nextC = firstC;
           while (c >= 0) {
             if (c == nextC) {
               index++;
               if (index == len) {
                 endFound = true;
                 break;
               }
               nextC = endPassThrough.codeUnitAt(index);
             } else if (c == firstC) {
               index = 1;
               nextC = endPassThrough.codeUnitAt(1);
             } else {
               index = 0;
               nextC = firstC;
             }
-            c = recordStartOfLineAndAdvance(c);
+            c = _recordStartOfLineAndAdvance(c);
           }
           if (start + 1 < offset) {
             if (endFound) {
-              emitWithOffsetAndLength(TokenType.TEXT, start + 1, -len);
-              emitWithOffset(TokenType.LT_SLASH, offset - len + 1);
-              emitWithOffsetAndLength(TokenType.TAG, offset - len + 3, -1);
+              _emitWithOffsetAndLength(TokenType.TEXT, start + 1, -len);
+              _emitWithOffset(TokenType.LT_SLASH, offset - len + 1);
+              _emitWithOffsetAndLength(TokenType.TAG, offset - len + 3, -1);
             } else {
-              emitWithOffsetAndLength(TokenType.TEXT, start + 1, -1);
+              _emitWithOffsetAndLength(TokenType.TEXT, start + 1, -1);
             }
           }
           endPassThrough = null;
         }
       } else if (c == 0x2F && peek() == 0x3E) {
         advance();
-        emitWithOffset(TokenType.SLASH_GT, start);
+        _emitWithOffset(TokenType.SLASH_GT, start);
         inBrackets = false;
         c = advance();
       } else if (!inBrackets) {
-        c = recordStartOfLineAndAdvance(c);
+        c = _recordStartOfLineAndAdvance(c);
         while (c != 0x3C && c >= 0) {
-          c = recordStartOfLineAndAdvance(c);
+          c = _recordStartOfLineAndAdvance(c);
         }
-        emitWithOffsetAndLength(TokenType.TEXT, start, -1);
+        _emitWithOffsetAndLength(TokenType.TEXT, start, -1);
       } else if (c == 0x22 || c == 0x27) {
         // read a string
         int endQuote = c;
         c = advance();
         while (c >= 0) {
           if (c == endQuote) {
             c = advance();
             break;
           }
-          c = recordStartOfLineAndAdvance(c);
+          c = _recordStartOfLineAndAdvance(c);
         }
-        emitWithOffsetAndLength(TokenType.STRING, start, -1);
+        _emitWithOffsetAndLength(TokenType.STRING, start, -1);
       } else if (c == 0x3D) {
         // a non-char token
-        emitWithOffset(TokenType.EQ, start);
+        _emitWithOffset(TokenType.EQ, start);
         c = advance();
       } else if (Character.isWhitespace(c)) {
         // ignore whitespace in braces
         do {
-          c = recordStartOfLineAndAdvance(c);
+          c = _recordStartOfLineAndAdvance(c);
         } while (Character.isWhitespace(c));
       } else if (Character.isLetterOrDigit(c)) {
         c = advance();
         while (Character.isLetterOrDigit(c) || c == 0x2D || c == 0x5F) {
           c = advance();
         }
-        emitWithOffsetAndLength(TokenType.TAG, start, -1);
+        _emitWithOffsetAndLength(TokenType.TAG, start, -1);
       } else {
         // a non-char token
-        emitWithOffsetAndLength(TokenType.TEXT, start, 0);
+        _emitWithOffsetAndLength(TokenType.TEXT, start, 0);
         c = advance();
       }
     }
   }
 }
 
 /**
  * Instances of the class `StringScanner` implement a scanner that reads from a string. The
  * scanning logic is in the superclass.
  */
@@ skipping 66 matching lines @@
    * @param writer the writer to which the source is to be written
    */
   ToSourceVisitor(PrintWriter writer) {
     this._writer = writer;
   }
 
   Object visitHtmlScriptTagNode(HtmlScriptTagNode node) => visitXmlTagNode(node);
 
   Object visitHtmlUnit(HtmlUnit node) {
     for (XmlTagNode child in node.tagNodes) {
-      visit(child);
+      _visit(child);
     }
     return null;
   }
 
   Object visitXmlAttributeNode(XmlAttributeNode node) {
     String name = node.name;
     Token value = node.valueToken;
     if (name.length == 0) {
       _writer.print("__");
     } else {
       _writer.print(name);
     }
     _writer.print("=");
     if (value == null) {
       _writer.print("__");
     } else {
       _writer.print(value.lexeme);
     }
     return null;
   }
 
   Object visitXmlTagNode(XmlTagNode node) {
     _writer.print("<");
     String tagName = node.tag;
     _writer.print(tagName);
     for (XmlAttributeNode attribute in node.attributes) {
       _writer.print(" ");
-      visit(attribute);
+      _visit(attribute);
     }
     _writer.print(node.attributeEnd.lexeme);
     if (node.closingTag != null) {
       for (XmlTagNode child in node.tagNodes) {
-        visit(child);
+        _visit(child);
       }
       _writer.print("</");
       _writer.print(tagName);
       _writer.print(">");
     }
     return null;
   }
 
   /**
    * Safely visit the given node.
    *
    * @param node the node to be visited
    */
-  void visit(XmlNode node) {
+  void _visit(XmlNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 }
 
 /**
  * The enumeration `TokenType` defines the types of tokens that can be returned by the
  * scanner.
  */
@@ skipping 276 matching lines @@
    * token stream.
    *
    * @return the list of tag nodes found (not `null`, contains no `null`)
    */
   List<XmlTagNode> parseTopTagNodes(Token firstToken) {
     _currentToken = firstToken;
     List<XmlTagNode> tagNodes = new List<XmlTagNode>();
     TokenType type = _currentToken.type;
     while (type != TokenType.EOF) {
       if (identical(type, TokenType.LT)) {
-        tagNodes.add(parseTagNode());
+        tagNodes.add(_parseTagNode());
       } else if (identical(type, TokenType.DECLARATION) || identical(type, TokenType.DIRECTIVE) || identical(type, TokenType.COMMENT)) {
         // ignored tokens
         _currentToken = _currentToken.next;
       } else {
-        reportUnexpectedToken();
+        _reportUnexpectedToken();
         _currentToken = _currentToken.next;
       }
       type = _currentToken.type;
     }
     return tagNodes;
   }
 
   /**
    * Answer the current token.
    *
    * @return the current token
    */
   Token get currentToken => _currentToken;
 
   /**
    * Insert a synthetic token of the specified type before the current token
    *
    * @param type the type of token to be inserted (not `null`)
    * @return the synthetic token that was inserted (not `null`)
    */
-  Token insertSyntheticToken(TokenType type) {
+  Token _insertSyntheticToken(TokenType type) {
     Token token = new Token.con2(type, _currentToken.offset, "");
     _currentToken.previous.setNext(token);
     token.setNext(_currentToken);
     return token;
   }
 
   /**
    * Parse the token stream for an attribute. This method advances the current token over the
    * attribute, but should not be called if the [currentToken] is not [TokenType#TAG].
    *
    * @return the attribute (not `null`)
    */
-  XmlAttributeNode parseAttribute() {
+  XmlAttributeNode _parseAttribute() {
     // Assume the current token is a tag
     Token name = _currentToken;
     _currentToken = _currentToken.next;
     // Equals sign
     Token equals;
     if (identical(_currentToken.type, TokenType.EQ)) {
       equals = _currentToken;
       _currentToken = _currentToken.next;
     } else {
-      reportUnexpectedToken();
-      equals = insertSyntheticToken(TokenType.EQ);
+      _reportUnexpectedToken();
+      equals = _insertSyntheticToken(TokenType.EQ);
     }
     // String value
     Token value;
     if (identical(_currentToken.type, TokenType.STRING)) {
       value = _currentToken;
       _currentToken = _currentToken.next;
     } else {
-      reportUnexpectedToken();
-      value = insertSyntheticToken(TokenType.STRING);
+      _reportUnexpectedToken();
+      value = _insertSyntheticToken(TokenType.STRING);
     }
     return createAttributeNode(name, equals, value);
   }
 
   /**
    * Parse the stream for a sequence of attributes. This method advances the current token to the
    * next [TokenType#GT], [TokenType#SLASH_GT], or [TokenType#EOF].
    *
    * @return a collection of zero or more attributes (not `null`, contains no `null`s)
    */
-  List<XmlAttributeNode> parseAttributes() {
+  List<XmlAttributeNode> _parseAttributes() {
     TokenType type = _currentToken.type;
     if (identical(type, TokenType.GT) || identical(type, TokenType.SLASH_GT) || identical(type, TokenType.EOF)) {
       return XmlTagNode.NO_ATTRIBUTES;
     }
     List<XmlAttributeNode> attributes = new List<XmlAttributeNode>();
     while (type != TokenType.GT && type != TokenType.SLASH_GT && type != TokenType.EOF) {
       if (identical(type, TokenType.TAG)) {
-        attributes.add(parseAttribute());
+        attributes.add(_parseAttribute());
       } else {
-        reportUnexpectedToken();
+        _reportUnexpectedToken();
         _currentToken = _currentToken.next;
       }
       type = _currentToken.type;
     }
     return attributes;
   }
 
   /**
    * Parse the stream for a sequence of tag nodes existing within a parent tag node. This method
    * advances the current token to the next [TokenType#LT_SLASH] or [TokenType#EOF].
    *
    * @return a list of nodes (not `null`, contains no `null`s)
    */
-  List<XmlTagNode> parseChildTagNodes() {
+  List<XmlTagNode> _parseChildTagNodes() {
     TokenType type = _currentToken.type;
     if (identical(type, TokenType.LT_SLASH) || identical(type, TokenType.EOF)) {
       return XmlTagNode.NO_TAG_NODES;
     }
     List<XmlTagNode> nodes = new List<XmlTagNode>();
     while (type != TokenType.LT_SLASH && type != TokenType.EOF) {
       if (identical(type, TokenType.LT)) {
-        nodes.add(parseTagNode());
+        nodes.add(_parseTagNode());
       } else if (identical(type, TokenType.COMMENT)) {
         // ignored token
         _currentToken = _currentToken.next;
       } else {
-        reportUnexpectedToken();
+        _reportUnexpectedToken();
         _currentToken = _currentToken.next;
       }
       type = _currentToken.type;
     }
     return nodes;
   }
 
   /**
    * Parse the token stream for the next tag node. This method advances current token over the
    * parsed tag node, but should only be called if the current token is [TokenType#LT]
    *
    * @return the tag node or `null` if none found
    */
-  XmlTagNode parseTagNode() {
+  XmlTagNode _parseTagNode() {
     // Assume that the current node is a tag node start TokenType#LT
     Token nodeStart = _currentToken;
     _currentToken = _currentToken.next;
     // Get the tag or create a synthetic tag and report an error
     Token tag;
     if (identical(_currentToken.type, TokenType.TAG)) {
       tag = _currentToken;
       _currentToken = _currentToken.next;
     } else {
-      reportUnexpectedToken();
-      tag = insertSyntheticToken(TokenType.TAG);
+      _reportUnexpectedToken();
+      tag = _insertSyntheticToken(TokenType.TAG);
     }
     // Parse the attributes
-    List<XmlAttributeNode> attributes = parseAttributes();
+    List<XmlAttributeNode> attributes = _parseAttributes();
     // Token ending attribute list
     Token attributeEnd;
     if (identical(_currentToken.type, TokenType.GT) || identical(_currentToken.type, TokenType.SLASH_GT)) {
       attributeEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
-      reportUnexpectedToken();
-      attributeEnd = insertSyntheticToken(TokenType.SLASH_GT);
+      _reportUnexpectedToken();
+      attributeEnd = _insertSyntheticToken(TokenType.SLASH_GT);
     }
     // If the node has no children, then return the node
     if (identical(attributeEnd.type, TokenType.SLASH_GT) || isSelfClosing(tag)) {
       return createTagNode(nodeStart, tag, attributes, attributeEnd, XmlTagNode.NO_TAG_NODES, _currentToken, null, attributeEnd);
     }
     // Parse the child tag nodes
-    List<XmlTagNode> tagNodes = parseChildTagNodes();
+    List<XmlTagNode> tagNodes = _parseChildTagNodes();
     // Token ending child tag nodes
     Token contentEnd;
     if (identical(_currentToken.type, TokenType.LT_SLASH)) {
       contentEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       // TODO (danrubel): handle self closing HTML elements by inserting synthetic tokens
       // but not reporting an error
-      reportUnexpectedToken();
-      contentEnd = insertSyntheticToken(TokenType.LT_SLASH);
+      _reportUnexpectedToken();
+      contentEnd = _insertSyntheticToken(TokenType.LT_SLASH);
     }
     // Closing tag
     Token closingTag;
     if (identical(_currentToken.type, TokenType.TAG)) {
       closingTag = _currentToken;
       _currentToken = _currentToken.next;
     } else {
-      reportUnexpectedToken();
-      closingTag = insertSyntheticToken(TokenType.TAG);
+      _reportUnexpectedToken();
+      closingTag = _insertSyntheticToken(TokenType.TAG);
     }
     // Token ending node
     Token nodeEnd;
     if (identical(_currentToken.type, TokenType.GT)) {
       nodeEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
-      reportUnexpectedToken();
-      nodeEnd = insertSyntheticToken(TokenType.GT);
+      _reportUnexpectedToken();
+      nodeEnd = _insertSyntheticToken(TokenType.GT);
     }
     return createTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
   }
 
   /**
    * Report the current token as unexpected
    */
-  void reportUnexpectedToken() {
+  void _reportUnexpectedToken() {
   }
 }
 
 /**
  * Instances of `XmlTagNode` represent XML or HTML elements such as `` and
  * `<body foo="bar"> ... </body>`.
  */
 class XmlTagNode extends XmlNode {
   /**
    * Constant representing empty list of attributes.
@@ skipping 295 matching lines @@
    */
   HtmlUnit parse(Token token, LineInfo lineInfo) {
     this._lineInfo = lineInfo;
     List<XmlTagNode> tagNodes = parseTopTagNodes(token);
     return new HtmlUnit(token, tagNodes, currentToken);
   }
 
   XmlAttributeNode createAttributeNode(Token name, Token equals, Token value) => new XmlAttributeNode(name, equals, value);
 
   XmlTagNode createTagNode(Token nodeStart, Token tag, List<XmlAttributeNode> attributes, Token attributeEnd, List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd) {
-    if (isScriptNode(tag, attributes, tagNodes)) {
+    if (_isScriptNode(tag, attributes, tagNodes)) {
       HtmlScriptTagNode tagNode = new HtmlScriptTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
       String contents = tagNode.content;
       int contentOffset = attributeEnd.end;
       LineInfo_Location location = _lineInfo.getLocation(contentOffset);
       sc.Scanner scanner = new sc.Scanner(source, new sc.SubSequenceReader(contents, contentOffset), _errorListener);
       scanner.setSourceStart(location.lineNumber, location.columnNumber);
       sc.Token firstToken = scanner.tokenize();
       Parser parser = new Parser(source, _errorListener);
       CompilationUnit unit = parser.parseCompilationUnit(firstToken);
       unit.lineInfo = _lineInfo;
       tagNode.script = unit;
       return tagNode;
     }
     return new XmlTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
   }
 
   bool isSelfClosing(Token tag) => SELF_CLOSING.contains(tag.lexeme);
 
   /**
    * Determine if the specified node is a Dart script.
    *
    * @param node the node to be tested (not `null`)
    * @return `true` if the node is a Dart script
    */
-  bool isScriptNode(Token tag, List<XmlAttributeNode> attributes, List<XmlTagNode> tagNodes) {
+  bool _isScriptNode(Token tag, List<XmlAttributeNode> attributes, List<XmlTagNode> tagNodes) {
     if (tagNodes.length != 0 || tag.lexeme != _SCRIPT) {
       return false;
     }
     for (XmlAttributeNode attribute in attributes) {
       if (attribute.name == _TYPE) {
         Token valueToken = attribute.valueToken;
         if (valueToken != null) {
           String value = valueToken.lexeme;
           if (value == _APPLICATION_DART_IN_DOUBLE_QUOTES || value == _APPLICATION_DART_IN_SINGLE_QUOTES) {
             return true;
@@ skipping 60 matching lines @@
     }
     super.element = element;
   }
 
   void visitChildren(XmlVisitor visitor) {
     for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 }