Fixed breakage in template utility now that statics aren't inherited.

utils/template/tokenizer.dart

 // Copyright (c) 2011, 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.
 
 class Tokenizer extends TokenizerBase {
   TokenKind tmplTokens;
 
   bool _selectorParsing;
 
   Tokenizer(SourceFile source, bool skipWhitespace, [int index = 0])
@@ skipping 54 matching lines @@
       case tmplTokens.tokens[TokenKind.GREATER_THAN]:
         return _finishToken(TokenKind.GREATER_THAN);
       case tmplTokens.tokens[TokenKind.EQUAL]:
         if (inTag) {
           if (_maybeEatChar(tmplTokens.tokens[TokenKind.SINGLE_QUOTE])) {
             return finishQuotedAttrValue(
               tmplTokens.tokens[TokenKind.SINGLE_QUOTE]);
           } else if (_maybeEatChar(tmplTokens.tokens[TokenKind.DOUBLE_QUOTE])) {
             return finishQuotedAttrValue(
               tmplTokens.tokens[TokenKind.DOUBLE_QUOTE]);
-          } else if (isAttributeValueStart(_peekChar())) {
+          } else if (TokenizerHelpers.isAttributeValueStart(_peekChar())) {
             return finishAttrValue();
           }
         }
         return _finishToken(TokenKind.EQUAL);
       case tmplTokens.tokens[TokenKind.SLASH]:
         if (_maybeEatChar(tmplTokens.tokens[TokenKind.GREATER_THAN])) {
           return _finishToken(TokenKind.END_NO_SCOPE_TAG);          // />
         } else if (_maybeEatChar(tmplTokens.tokens[TokenKind.ASTERISK])) {
           return finishMultiLineComment();
         } else {
           return _finishToken(TokenKind.SLASH);
         }
       case tmplTokens.tokens[TokenKind.DOLLAR]:
         if (_maybeEatChar(tmplTokens.tokens[TokenKind.LBRACE])) {
           if (_maybeEatChar(tmplTokens.tokens[TokenKind.HASH])) {
             return _finishToken(TokenKind.START_COMMAND);           // ${#
           } else if (_maybeEatChar(tmplTokens.tokens[TokenKind.SLASH])) {
             return _finishToken(TokenKind.END_COMMAND);             // ${/
           } else {
             return _finishToken(TokenKind.START_EXPRESSION);        // ${
           }
         } else {
           return _finishToken(TokenKind.DOLLAR);
         }
 
       default:
         if (TokenizerHelpers.isIdentifierStart(ch)) {
           return this.finishIdentifier();
-        } else if (isDigit(ch)) {
+        } else if (TokenizerHelpers.isDigit(ch)) {
           return this.finishNumber();
         } else {
           return _errorToken();
         }
     }
   }
 
   // TODO(jmesserly): we need a way to emit human readable error messages from
   // the tokenizer.
   Token _errorToken([String message = null]) {
@@ skipping 57 matching lines @@
       } else {
         buf.add(ch);
       }
     }
   }
 
   Token finishAttrValue() {
     var buf = new List<int>();
     while (true) {
       int ch = _peekChar();
-      if (isWhitespace(ch) || isSlash(ch) || isCloseTag(ch)) {
+      if (TokenizerHelpers.isWhitespace(ch) || TokenizerHelpers.isSlash(ch) ||
+          TokenizerHelpers.isCloseTag(ch)) {
         return _makeAttributeValueToken(buf);
       } else if (ch == 0) {
         return _errorToken();
       } else {
         buf.add(_nextChar());
       }
     }
   }
 
   Token finishNumber() {
     eatDigits();
 
     if (_peekChar() == 46/*.*/) {
       // Handle the case of 1.toString().
       _nextChar();
-      if (isDigit(_peekChar())) {
+      if (TokenizerHelpers.isDigit(_peekChar())) {
         eatDigits();
         return _finishToken(TokenKind.DOUBLE);
       } else {
         _index -= 1;
       }
     }
 
     return _finishToken(TokenKind.INTEGER);
   }
 
   bool maybeEatDigit() {
-    if (_index < _text.length && isDigit(_text.charCodeAt(_index))) {
+    if (_index < _text.length && TokenizerHelpers.isDigit(
+        _text.charCodeAt(_index))) {
       _index += 1;
       return true;
     }
     return false;
   }
 
   void eatHexDigits() {
     while (_index < _text.length) {
-     if (isHexDigit(_text.charCodeAt(_index))) {
+     if (TokenizerHelpers.isHexDigit(_text.charCodeAt(_index))) {
        _index += 1;
      } else {
        return;
      }
     }
   }
 
   bool maybeEatHexDigit() {
-    if (_index < _text.length && isHexDigit(_text.charCodeAt(_index))) {
+    if (_index < _text.length && TokenizerHelpers.isHexDigit(
+        _text.charCodeAt(_index))) {
       _index += 1;
       return true;
     }
     return false;
   }
 
   Token finishMultiLineComment() {
     while (true) {
       int ch = _nextChar();
       if (ch == 0) {
@@ skipping 60 matching lines @@
   }
 
   static bool isSlash(int c) {
     return (c == 47/* / */);
   }
 
   static bool isCloseTag(int c) {
     return (c == 62/* > */);
   }
 }