New analyzer snapshot.

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart' show Token, Scanner, CharSequenceReader;
 import 'ast.dart';
 import 'parser.dart' show Parser;
 import 'sdk.dart' show DartSdk;
 import 'element.dart';
 import 'resolver.dart';
-import 'html.dart' show XmlTagNode, XmlAttributeNode, RecursiveXmlVisitor, HtmlScanner, HtmlScanResult, HtmlParser, HtmlParseResult, HtmlUnit;
+import 'html.dart' show XmlTagNode, XmlAttributeNode, RecursiveXmlVisitor, HtmlScanner, HtmlScanResult, HtmlParser, HtmlParseResult, HtmlScriptTagNode, HtmlUnit;
 
 /**
  * The unique instance of the class `AnalysisEngine` serves as the entry point for the
  * functionality provided by the analysis engine.
  *
  * @coverage dart.engine
  */
 class AnalysisEngine {
   /**
    * The suffix used for Dart source files.
@@ skipping 674 matching lines @@
    */
   bool get dart2jsHint;
 
   /**
    * Return `true` if analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    *
    * @return `true` if analysis is to generate hint results
    */
   bool get hint;
-
-  /**
-   * Return `true` if analysis is to use strict mode. In strict mode, error reporting is based
-   * exclusively on the static type information.
-   *
-   * @return `true` if analysis is to use strict mode
-   */
-  bool get strictMode;
 }
 
 /**
  * Instances of the class `AnalysisResult`
  */
 class AnalysisResult {
   /**
    * The change notices associated with this result, or `null` if there were no changes and
    * there is no more work to be done.
    */
@@ skipping 1626 matching lines @@
  */
 abstract class HtmlEntry implements SourceEntry {
   /**
    * The data descriptor representing the HTML element.
    */
   static final DataDescriptor<HtmlElement> ELEMENT = new DataDescriptor<HtmlElement>("HtmlEntry.ELEMENT");
 
   /**
    * The data descriptor representing the hints resulting from auditing the source.
    */
-  static final DataDescriptor<List<AnalysisError>> HINTS = new DataDescriptor<List<AnalysisError>>("DartEntry.HINTS");
+  static final DataDescriptor<List<AnalysisError>> HINTS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.HINTS");
+
+  /**
+   * The data descriptor representing the errors resulting from parsing the source.
+   */
+  static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.PARSE_ERRORS");
 
   /**
    * The data descriptor representing the parsed AST structure.
    */
   static final DataDescriptor<HtmlUnit> PARSED_UNIT = new DataDescriptor<HtmlUnit>("HtmlEntry.PARSED_UNIT");
 
   /**
    * The data descriptor representing the list of referenced libraries.
    */
   static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES = new DataDescriptor<List<Source>>("HtmlEntry.REFERENCED_LIBRARIES");
@@ skipping 23 matching lines @@
    * The state of the cached parsed (but not resolved) HTML unit.
    */
   CacheState _parsedUnitState = CacheState.INVALID;
 
   /**
    * The parsed HTML unit, or `null` if the parsed HTML unit is not currently cached.
    */
   HtmlUnit _parsedUnit;
 
   /**
+   * The state of the cached parse errors.
+   */
+  CacheState _parseErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while scanning and parsing the HTML, or `null` if the errors are not
+   * currently cached.
+   */
+  List<AnalysisError> _parseErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * The state of the cached resolution errors.
    */
   CacheState _resolutionErrorsState = CacheState.INVALID;
 
   /**
-   * The errors produced while resolving the compilation unit, or `null` if the errors are not
-   * currently cached.
+   * The errors produced while resolving the HTML, or `null` if the errors are not currently
+   * cached.
    */
   List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The state of the cached list of referenced libraries.
    */
   CacheState _referencedLibrariesState = CacheState.INVALID;
 
   /**
    * The list of libraries referenced in the HTML, or `null` if the list is not currently
@@ skipping 17 matching lines @@
   CacheState _hintsState = CacheState.INVALID;
 
   /**
    * The hints produced while auditing the compilation unit, or an empty array if the hints are not
    * currently cached.
    */
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
+    for (AnalysisError error in _parseErrors) {
+      errors.add(error);
+    }
     for (AnalysisError error in _resolutionErrors) {
       errors.add(error);
     }
     for (AnalysisError error in _hints) {
       errors.add(error);
     }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
   SourceKind get kind => SourceKind.HTML;
 
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _elementState;
+    } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
+      return _parseErrorsState;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibrariesState;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrorsState;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hintsState;
     }
     return super.getState(descriptor);
   }
 
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _element as Object;
+    } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
+      return _parseErrors as Object;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnit as Object;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibraries as Object;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrors as Object;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hints as Object;
     }
     return super.getValue(descriptor);
   }
 
   HtmlEntryImpl get writableCopy {
     HtmlEntryImpl copy = new HtmlEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
   /**
    * Invalidate all of the information associated with the HTML file.
    */
   void invalidateAllInformation() {
     setState(SourceEntry.LINE_INFO, CacheState.INVALID);
+    _parseErrors = AnalysisError.NO_ERRORS;
+    _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitState = CacheState.INVALID;
     _referencedLibraries = Source.EMPTY_ARRAY;
     _referencedLibrariesState = CacheState.INVALID;
     invalidateAllResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the HTML file.
    */
   void invalidateAllResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
 
   /**
    * Record that an error was encountered while attempting to parse the source associated with this
    * entry.
    */
   void recordParseError() {
     setState(SourceEntry.LINE_INFO, CacheState.ERROR);
+    setState(HtmlEntry.PARSE_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
     setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
     recordResolutionError();
   }
 
   /**
    * Record that an error was encountered while attempting to resolve the source associated with
    * this entry.
    */
   void recordResolutionError() {
     setState(HtmlEntry.ELEMENT, CacheState.ERROR);
     setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.HINTS, CacheState.ERROR);
   }
 
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
+    } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
+      _parseErrors = updatedValue(state, _parseErrors, null);
+      _parseErrorsState = state;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _parsedUnit = updatedValue(state, _parsedUnit, null);
       _parsedUnitState = state;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = updatedValue(state, _referencedLibraries, Source.EMPTY_ARRAY);
       _referencedLibrariesState = state;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       _resolutionErrors = updatedValue(state, _resolutionErrors, AnalysisError.NO_ERRORS);
       _resolutionErrorsState = state;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       _hints = updatedValue(state, _hints, AnalysisError.NO_ERRORS);
       _hintsState = state;
     } else {
       super.setState(descriptor, state);
     }
   }
 
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       _element = value as HtmlElement;
       _elementState = CacheState.VALID;
+    } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
+      _parseErrors = value as List<AnalysisError>;
+      _parseErrorsState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _parsedUnit = value as HtmlUnit;
       _parsedUnitState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _referencedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       _resolutionErrors = value as List<AnalysisError>;
       _resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       _hints = value as List<AnalysisError>;
       _hintsState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
 
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     HtmlEntryImpl other = entry as HtmlEntryImpl;
+    _parseErrorsState = other._parseErrorsState;
+    _parseErrors = other._parseErrors;
     _parsedUnitState = other._parsedUnitState;
     _parsedUnit = other._parsedUnit;
     _referencedLibrariesState = other._referencedLibrariesState;
     _referencedLibraries = other._referencedLibraries;
     _resolutionErrors = other._resolutionErrors;
     _resolutionErrorsState = other._resolutionErrorsState;
     _elementState = other._elementState;
     _element = other._element;
     _hints = other._hints;
     _hintsState = other._hintsState;
   }
 
   void writeOn(JavaStringBuilder builder) {
     builder.append("Html: ");
     super.writeOn(builder);
+    builder.append("; parseErrors = ");
+    builder.append(_parseErrorsState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append("; resolutionErrors = ");
     builder.append(_resolutionErrorsState);
     builder.append("; referencedLibraries = ");
     builder.append(_referencedLibrariesState);
     builder.append("; element = ");
     builder.append(_elementState);
   }
 }
@@ skipping 272 matching lines @@
     String rowName = rowDesc.toString();
     AnalysisContentStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContentStatisticsImpl_CacheRowImpl;
     if (row == null) {
       row = new AnalysisContentStatisticsImpl_CacheRowImpl(rowName);
       _dataMap[rowName] = row;
     }
     row.incState(state);
     if (identical(state, CacheState.ERROR)) {
       AnalysisException exception = dartEntry.exception;
       if (exception != null) {
-        javaSetAdd(_exceptions, exception);
+        _exceptions.add(exception);
       }
     }
   }
 }
 
 class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
   String _name;
 
   int _errorCount = 0;
 
@@ skipping 728 matching lines @@
         _cache.maxCacheSize = cacheSize;
         int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
         if (_priorityOrder.length > maxPriorityOrderSize) {
           List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
           JavaSystem.arraycopy(_priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
           _priorityOrder = newPriorityOrder;
         }
       }
       this._options.dart2jsHint = options.dart2jsHint;
       this._options.hint = options.hint;
-      this._options.strictMode = options.strictMode;
       if (needsRecompute) {
         invalidateAllResolutionInformation();
       }
     }
   }
 
   void set analysisPriorityOrder(List<Source> sources) {
     {
       if (sources == null || sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
       } else {
         while (sources.remove(null)) {
         }
         if (sources.isEmpty) {
           _priorityOrder = Source.EMPTY_ARRAY;
         }
         int count = Math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
         _priorityOrder = new List<Source>(count);
         for (int i = 0; i < count; i++) {
           _priorityOrder[i] = sources[i];
         }
       }
     }
   }
 
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     {
       String originalContents = _sourceFactory.setContents(source, contents);
-      if (originalContents == null) {
-        if (contents != null) {
+      if (contents != null) {
+        if (contents != originalContents) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
           sourceChanged(source);
         }
-      } else if (originalContents != contents) {
-        _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
+      } else if (originalContents != null) {
+        _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
-      } else if (contents == null) {
-        _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       }
     }
   }
 
   void setContents(Source source, String contents) {
     {
       String originalContents = _sourceFactory.setContents(source, contents);
-      if (originalContents == null) {
-        if (contents != null) {
+      if (contents != null) {
+        if (contents != originalContents) {
+          _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
           sourceChanged(source);
         }
-      } else if (originalContents != contents) {
+      } else if (originalContents != null) {
+        _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
-      _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
     }
   }
 
   void set sourceFactory(SourceFactory factory) {
     {
       if (identical(_sourceFactory, factory)) {
         return;
       } else if (factory.context != null) {
         throw new IllegalStateException("Source factories cannot be shared between contexts");
       }
@@ skipping 704 matching lines @@
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
    * @param sources the set to which sources should be added
    */
   void getSourcesNeedingProcessing2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, Set<Source> sources) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
-        javaSetAdd(sources, source);
+        sources.add(source);
         return;
       }
       if (isPriority) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
-          javaSetAdd(sources, source);
+          sources.add(source);
           return;
         }
       }
       for (Source librarySource in getLibrariesContaining(source)) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
-            javaSetAdd(sources, source);
+            sources.add(source);
             return;
           }
           CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
           if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
             LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
-              javaSetAdd(sources, source);
+              sources.add(source);
               return;
             }
           }
           CacheState verificationErrorsState = dartEntry.getState2(DartEntry.VERIFICATION_ERRORS, librarySource);
           if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
             LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
-              javaSetAdd(sources, source);
+              sources.add(source);
               return;
             }
           }
           if (hintsEnabled) {
             CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
             if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
               LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
               if (libraryElement != null) {
-                javaSetAdd(sources, source);
+                sources.add(source);
                 return;
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
       CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
       if (identical(parsedUnitState, CacheState.INVALID) || (isPriority && identical(parsedUnitState, CacheState.FLUSHED))) {
-        javaSetAdd(sources, source);
+        sources.add(source);
         return;
       }
       CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
       if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
-        javaSetAdd(sources, source);
+        sources.add(source);
         return;
       }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
@@ skipping 47 matching lines @@
    *          infinite recursion
    * @return `true` if this library is, or depends on, dart:html
    */
   bool isClient(LibraryElement library, Source htmlSource, Set<LibraryElement> visitedLibraries) {
     if (visitedLibraries.contains(library)) {
       return false;
     }
     if (library.source == htmlSource) {
       return true;
     }
-    javaSetAdd(visitedLibraries, library);
+    visitedLibraries.add(library);
     for (LibraryElement imported in library.importedLibraries) {
       if (isClient(imported, htmlSource, visitedLibraries)) {
         return true;
       }
     }
     for (LibraryElement exported in library.exportedLibraries) {
       if (isClient(exported, htmlSource, visitedLibraries)) {
         return true;
       }
     }
@@ skipping 281 matching lines @@
           if (htmlEntry == null) {
             throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
           }
         }
         HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
         if (thrownException == null) {
           LineInfo lineInfo = task.lineInfo;
           HtmlUnit unit = task.htmlUnit;
           htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
           htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
+          htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
           htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
           ChangeNoticeImpl notice = getNotice(source);
           notice.setErrors(htmlEntry.allErrors, lineInfo);
         } else {
           htmlCopy.recordParseError();
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
@@ skipping 282 matching lines @@
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       htmlCopy.modificationTime = source.modificationStamp;
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
-        javaSetAdd(librariesToInvalidate, containingLibrary);
+        librariesToInvalidate.add(containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
-          javaSetAdd(librariesToInvalidate, dependentLibrary);
+          librariesToInvalidate.add(dependentLibrary);
         }
       }
       for (Source library in librariesToInvalidate) {
         invalidateLibraryResolution(library);
       }
       DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
       dartCopy.modificationTime = source.modificationStamp;
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void sourceRemoved(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
-        javaSetAdd(libraries, librarySource);
+        libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
-          javaSetAdd(libraries, dependentLibrary);
+          libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         invalidateLibraryResolution(librarySource);
       }
     }
     _cache.remove(source);
   }
 }
 
@@ skipping 108 matching lines @@
    */
   bool _dart2jsHint = true;
 
   /**
    * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
   bool _hint = true;
 
   /**
-   * A flag indicating whether analysis is to use strict mode. In strict mode, error reporting is
-   * based exclusively on the static type information.
-   */
-  bool _strictMode = true;
-
-  /**
    * Initialize a newly created set of analysis options to have their default values.
    */
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values as those in the
    * given set of analysis options.
    *
    * @param options the analysis options whose values are being copied
    */
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     _cacheSize = options.cacheSize;
     _dart2jsHint = options.dart2jsHint;
     _hint = options.hint;
-    _strictMode = options.strictMode;
   }
 
   int get cacheSize => _cacheSize;
 
   bool get dart2jsHint => _dart2jsHint;
 
   bool get hint => _hint;
 
   /**
-   * Return `true` if analysis is to use strict mode. In strict mode, error reporting is based
-   * exclusively on the static type information.
-   *
-   * @return `true` if analysis is to use strict mode
-   */
-  bool get strictMode => _strictMode;
-
-  /**
    * Set the maximum number of sources for which AST structures should be kept in the cache to the
    * given size.
    *
    * @param cacheSize the maximum number of sources for which AST structures should be kept in the
    *          cache
    */
   void set cacheSize(int cacheSize) {
     this._cacheSize = cacheSize;
   }
 
   /**
    * Set whether analysis is to generate dart2js related hint results.
    *
    * @param hint `true` if analysis is to generate dart2js related hint results
    */
   void set dart2jsHint(bool dart2jsHints) {
     this._dart2jsHint = dart2jsHints;
   }
 
   /**
    * Set whether analysis is to generate hint results (e.g. type inference based information and pub
    * best practices).
    *
    * @param hint `true` if analysis is to generate hint results
    */
   void set hint(bool hint) {
     this._hint = hint;
   }
-
-  /**
-   * Set whether analysis is to use strict mode to the given value. In strict mode, error reporting
-   * is based exclusively on the static type information.
-   *
-   * @param isStrict `true` if analysis is to use strict mode
-   */
-  void set strictMode(bool isStrict) {
-    _strictMode = isStrict;
-  }
 }
 
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  *
  * @coverage dart.engine
  */
 class ChangeNoticeImpl implements ChangeNotice {
   /**
@@ skipping 412 matching lines @@
       return null;
     }
     return cache;
   }
 
   /**
    * Determine if incremental analysis can be performed from the given information.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source being updated (not `null`)
-   * @param oldContents the original source contents prior to this update (not `null`)
+   * @param oldContents the original source contents prior to this update (may be `null`)
    * @param newContents the new contents after this incremental change (not `null`)
    * @param offset the offset at which the change occurred
    * @param oldLength the length of the text being replaced
    * @param newLength the length of the replacement text
    * @param sourceEntry the cached entry for the given source or `null` if none
    * @return the cache used for incremental analysis or `null` if incremental analysis cannot
    *         be performed
    */
   static IncrementalAnalysisCache update(IncrementalAnalysisCache cache, Source source, String oldContents, String newContents, int offset, int oldLength, int newLength, SourceEntry sourceEntry) {
     Source librarySource = null;
@@ skipping 39 matching lines @@
    * equivalent to the fully parsed unit.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source of the compilation unit that was parsed (not `null`)
    * @param unit the compilation unit that was just parsed
    * @return the cache used for incremental analysis or `null` if incremental analysis results
    *         cannot be cached for the next incremental analysis
    */
   static IncrementalAnalysisCache verifyStructure(IncrementalAnalysisCache cache, Source source, CompilationUnit unit) {
     if (cache != null && unit != null && cache.source == source) {
-      if (!ASTComparator.equals3(cache.resolvedUnit, unit)) {
+      if (!ASTComparator.equals4(cache.resolvedUnit, unit)) {
         return null;
       }
     }
     return cache;
   }
 
   Source librarySource;
 
   Source source;
 
@@ skipping 786 matching lines @@
     }
   }
 
   void onError(AnalysisError error) {
     Source source = error.source;
     Set<AnalysisError> errorsForSource = _errors[source];
     if (_errors[source] == null) {
       errorsForSource = new Set<AnalysisError>();
       _errors[source] = errorsForSource;
     }
-    javaSetAdd(errorsForSource, error);
+    errorsForSource.add(error);
   }
 }
 
 /**
  * Instances of the class `ResolutionEraser` remove any resolution information from an AST
  * structure when used to visit that structure.
  */
 class ResolutionEraser extends GeneralizingASTVisitor<Object> {
   Object visitAssignmentExpression(AssignmentExpression node) {
     node.staticElement = null;
@@ skipping 616 matching lines @@
       return "parse as dart null source";
     }
     return "parse as dart ${source.fullName}";
   }
 
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     List<Token> token = [null];
     TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
     try {
-      Source_ContentReceiver receiver = new Source_ContentReceiver_12(this, errorListener, token);
+      Source_ContentReceiver receiver = new Source_ContentReceiver_11(this, errorListener, token);
       try {
         source.getContents(receiver);
       } on JavaException catch (exception) {
         modificationTime = source.modificationStamp;
         throw new AnalysisException.con3(exception);
       }
     } finally {
       timeCounterScan.stop();
     }
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       Parser parser = new Parser(source, errorListener);
       compilationUnit = parser.parseCompilationUnit(token[0]);
       errors = errorListener.getErrors2(source);
       for (Directive directive in compilationUnit.directives) {
         if (directive is ExportDirective) {
           Source exportSource = resolveSource(source, directive as ExportDirective);
           if (exportSource != null) {
-            javaSetAdd(_exportedSources, exportSource);
+            _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
           Source importSource = resolveSource(source, directive as ImportDirective);
           if (importSource != null) {
-            javaSetAdd(_importedSources, importSource);
+            _importedSources.add(importSource);
           }
         } else if (directive is LibraryDirective) {
           _hasLibraryDirective2 = true;
         } else if (directive is PartDirective) {
           Source partSource = resolveSource(source, directive as PartDirective);
           if (partSource != null) {
-            javaSetAdd(_includedSources, partSource);
+            _includedSources.add(partSource);
           }
         } else if (directive is PartOfDirective) {
           _hasPartOfDirective2 = true;
         }
       }
       compilationUnit.lineInfo = lineInfo;
     } finally {
       timeCounterParse.stop();
     }
   }
@@ skipping 32 matching lines @@
    */
   List<Source> toArray(Set<Source> sources) {
     int size = sources.length;
     if (size == 0) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(sources);
   }
 }
 
-class Source_ContentReceiver_12 implements Source_ContentReceiver {
+class Source_ContentReceiver_11 implements Source_ContentReceiver {
   final ParseDartTask ParseDartTask_this;
 
   RecordingErrorListener errorListener;
 
   List<Token> token;
 
-  Source_ContentReceiver_12(this.ParseDartTask_this, this.errorListener, this.token);
+  Source_ContentReceiver_11(this.ParseDartTask_this, this.errorListener, this.token);
 
   void accept(CharBuffer contents, int modificationTime) {
     ParseDartTask_this.modificationTime = modificationTime;
     Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(contents), errorListener);
     token[0] = scanner.tokenize();
     ParseDartTask_this.lineInfo = new LineInfo(scanner.lineStarts);
   }
 
   void accept2(String contents, int modificationTime) {
     ParseDartTask_this.modificationTime = modificationTime;
@@ skipping 21 matching lines @@
    * The line information that was produced.
    */
   LineInfo lineInfo;
 
   /**
    * The HTML unit that was produced by parsing the source.
    */
   HtmlUnit htmlUnit;
 
   /**
+   * The errors that were produced by scanning and parsing the source.
+   */
+  List<AnalysisError> errors = AnalysisError.NO_ERRORS;
+
+  /**
    * An array containing the sources of the libraries that are referenced within the HTML.
    */
   List<Source> referencedLibraries = Source.EMPTY_ARRAY;
 
   /**
    * The name of the 'src' attribute in a HTML tag.
    */
   static String _ATTRIBUTE_SRC = "src";
 
   /**
@@ skipping 34 matching lines @@
   void internalPerform() {
     HtmlScanner scanner = new HtmlScanner(source);
     try {
       source.getContents(scanner);
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
     HtmlScanResult scannerResult = scanner.result;
     modificationTime = scannerResult.modificationTime;
     lineInfo = new LineInfo(scannerResult.lineStarts);
-    HtmlParseResult result = new HtmlParser(source).parse(scannerResult);
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    HtmlParseResult result = new HtmlParser(source, errorListener).parse(scannerResult);
     htmlUnit = result.htmlUnit;
+    errors = errorListener.getErrors2(source);
     referencedLibraries = librarySources;
   }
 
   /**
    * Return the sources of libraries that are referenced in the specified HTML file.
    *
    * @return the sources of libraries that are referenced in the HTML file
    */
   List<Source> get librarySources {
     List<Source> libraries = new List<Source>();
-    htmlUnit.accept(new RecursiveXmlVisitor_13(this, libraries));
+    htmlUnit.accept(new RecursiveXmlVisitor_12(this, libraries));
     if (libraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(libraries);
   }
 }
 
-class RecursiveXmlVisitor_13 extends RecursiveXmlVisitor<Object> {
+class RecursiveXmlVisitor_12 extends RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
 
   List<Source> libraries;
 
-  RecursiveXmlVisitor_13(this.ParseHtmlTask_this, this.libraries) : super();
+  RecursiveXmlVisitor_12(this.ParseHtmlTask_this, this.libraries) : super();
 
-  Object visitXmlTagNode(XmlTagNode node) {
-    if (javaStringEqualsIgnoreCase(node.tag.lexeme, ParseHtmlTask._TAG_SCRIPT)) {
-      bool isDartScript = false;
-      XmlAttributeNode scriptAttribute = null;
-      for (XmlAttributeNode attribute in node.attributes) {
-        if (javaStringEqualsIgnoreCase(attribute.name.lexeme, ParseHtmlTask._ATTRIBUTE_SRC)) {
-          scriptAttribute = attribute;
-        } else if (javaStringEqualsIgnoreCase(attribute.name.lexeme, ParseHtmlTask._ATTRIBUTE_TYPE)) {
-          if (javaStringEqualsIgnoreCase(attribute.text, ParseHtmlTask._TYPE_DART)) {
-            isDartScript = true;
-          }
-        }
-      }
-      if (isDartScript && scriptAttribute != null) {
-        try {
-          Uri uri = new Uri(path: scriptAttribute.text);
-          String fileName = uri.path;
-          Source librarySource = ParseHtmlTask_this.context.sourceFactory.resolveUri(ParseHtmlTask_this.source, fileName);
-          if (librarySource != null && librarySource.exists()) {
-            libraries.add(librarySource);
-          }
-        } on URISyntaxException catch (e) {
-        }
+  Object visitHtmlScriptTagNode(HtmlScriptTagNode node) {
+    XmlAttributeNode scriptAttribute = null;
+    for (XmlAttributeNode attribute in node.attributes) {
+      if (javaStringEqualsIgnoreCase(attribute.name.lexeme, ParseHtmlTask._ATTRIBUTE_SRC)) {
+        scriptAttribute = attribute;
       }
     }
-    return super.visitXmlTagNode(node);
+    if (scriptAttribute != null) {
+      try {
+        Uri uri = new Uri(path: scriptAttribute.text);
+        String fileName = uri.path;
+        Source librarySource = ParseHtmlTask_this.context.sourceFactory.resolveUri(ParseHtmlTask_this.source, fileName);
+        if (librarySource != null && librarySource.exists()) {
+          libraries.add(librarySource);
+        }
+      } on URISyntaxException catch (e) {
+      }
+    }
+    return super.visitHtmlScriptTagNode(node);
   }
 }
 
 /**
  * Instances of the class `ResolveDartLibraryTask` parse a specific Dart library.
  */
 class ResolveDartLibraryTask extends AnalysisTask {
   /**
    * The source representing the file whose compilation unit is to be returned.
    */
@@ skipping 266 matching lines @@
 
   void logError3(Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation2(String message, Exception exception) {
   }
 }