New analyzer snapshot, based on r35422.

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'java_core.dart';
@@ skipping 4540 matching lines @@
       // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
       // that might have been referencing the not-yet-existing source that was just added. Longer
       // term we need to keep track of which libraries are referencing non-existing sources and
       // only re-analyze those libraries.
       //        logInformation("Added Dart sources, invalidating all resolution information");
       List<Source> sourcesToInvalidate = new List<Source>();
       MapIterator<Source, SourceEntry> iterator = _cache.iterator();
       while (iterator.moveNext()) {
         Source source = iterator.key;
         SourceEntry sourceEntry = iterator.value;
-        if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
+        if (!source.isInSystemLibrary && (sourceEntry is DartEntry || sourceEntry is HtmlEntry)) {
           sourcesToInvalidate.add(source);
         }
       }
       int count = sourcesToInvalidate.length;
       for (int i = 0; i < count; i++) {
         Source source = sourcesToInvalidate[i];
-        DartEntry dartEntry = _getReadableDartEntry(source);
-        _removeFromParts(source, dartEntry);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        dartCopy.invalidateAllResolutionInformation();
-        _cache.put(source, dartCopy);
-        SourcePriority priority = SourcePriority.UNKNOWN;
-        SourceKind kind = dartCopy.kind;
-        if (kind == SourceKind.LIBRARY) {
-          priority = SourcePriority.LIBRARY;
-        } else if (kind == SourceKind.PART) {
-          priority = SourcePriority.NORMAL_PART;
+        SourceEntry entry = _getReadableSourceEntry(source);
+        if (entry is DartEntry) {
+          DartEntry dartEntry = entry;
+          _removeFromParts(source, dartEntry);
+          DartEntryImpl dartCopy = dartEntry.writableCopy;
+          dartCopy.invalidateAllResolutionInformation();
+          _cache.put(source, dartCopy);
+          SourcePriority priority = SourcePriority.UNKNOWN;
+          SourceKind kind = dartCopy.kind;
+          if (kind == SourceKind.LIBRARY) {
+            priority = SourcePriority.LIBRARY;
+          } else if (kind == SourceKind.PART) {
+            priority = SourcePriority.NORMAL_PART;
+          }
+          _workManager.add(source, priority);
         }
-        _workManager.add(source, priority);
+        if (entry is HtmlEntry) {
+          HtmlEntry htmlEntry = entry;
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.invalidateAllResolutionInformation();
+          _cache.put(source, htmlCopy);
+          _workManager.add(source, SourcePriority.HTML);
+        }
       }
     }
   }
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
@@ skipping 8570 matching lines @@
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
-                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+                ErrorCode errorCode = (importElement.isDeferred ? StaticWarningCode.IMPORT_OF_NON_LIBRARY : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, errorCode, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           if (exportedSource != null && analysisContext.exists(exportedSource)) {
             // The exported source will be null if the URI in the export directive was invalid.
             ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
@@ skipping 111 matching lines @@
     return identifiers;
   }
 }
 
 /**
  * Instances of the class `GenerateDartErrorsTask` generate errors and warnings for a single
  * Dart source.
  */
 class GenerateDartErrorsTask extends AnalysisTask {
   /**
+   * Check each directive in the given compilation unit to see if the referenced source exists and
+   * report an error if it does not.
+   *
+   * @param context the context in which the library exists
+   * @param librarySource the source representing the library containing the directives
+   * @param unit the compilation unit containing the directives to be validated
+   * @param errorListener the error listener to which errors should be reported
+   */
+  static void validateDirectives(AnalysisContext context, Source librarySource, CompilationUnit unit, AnalysisErrorListener errorListener) {
+    for (Directive directive in unit.directives) {
+      if (directive is UriBasedDirective) {
+        validateReferencedSource(context, librarySource, directive, errorListener);
+      }
+    }
+  }
+
+  /**
+   * Check the given directive to see if the referenced source exists and report an error if it does
+   * not.
+   *
+   * @param context the context in which the library exists
+   * @param librarySource the source representing the library containing the directive
+   * @param directive the directive to be verified
+   * @param errorListener the error listener to which errors should be reported
+   */
+  static void validateReferencedSource(AnalysisContext context, Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
+    Source source = directive.source;
+    if (source != null) {
+      if (context.exists(source)) {
+        return;
+      }
+    } else {
+      // Don't report errors already reported by ParseDartTask#resolveDirective
+      if (directive.validate() != null) {
+        return;
+      }
+    }
+    StringLiteral uriLiteral = directive.uri;
+    errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [directive.uriContent]));
+  }
+
+  /**
    * The source for which errors and warnings are to be produced.
    */
   final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   final int modificationTime;
 
   /**
@@ skipping 36 matching lines @@
   String get taskDescription => "generate errors and warnings for ${source.fullName}";
 
   @override
   void internalPerform() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       TypeProvider typeProvider = context.typeProvider;
       //
+      // Validate the directives
+      //
+      validateDirectives(context, source, _unit, errorListener);
+      //
       // Use the ConstantVerifier to verify the use of constants. This needs to happen before using
       // the ErrorVerifier because some error codes need the computed constant values.
       //
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
       _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, new InheritanceManager(libraryElement));
       _unit.accept(errorVerifier);
@@ skipping 268 matching lines @@
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param context the context in which the resolution is to be performed
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
    * @param errorListener the error listener to which errors should be reported
    * @return the result of resolving the URI against the URI of the library
    */
-  static Source resolveSource(AnalysisContext analysisContext, Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
+  static Source resolveDirective(AnalysisContext context, Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
     StringLiteral uriLiteral = directive.uri;
-    if (uriLiteral is StringInterpolation) {
+    String uriContent = uriLiteral.stringValue;
+    if (uriContent != null) {
+      uriContent = uriContent.trim();
+      directive.uriContent = uriContent;
+    }
+    UriValidationCode code = directive.validate();
+    if (code == null) {
+      String encodedUriContent = Uri.encodeFull(uriContent);
+      Source source = context.sourceFactory.resolveUri(librarySource, encodedUriContent);
+      directive.source = source;
+      return source;
+    }
+    if (code == UriValidationCode.URI_WITH_DART_EXT_SCHEME) {
+      return null;
+    }
+    if (code == UriValidationCode.URI_WITH_INTERPOLATION) {
       errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
       return null;
     }
-    String uriContent = uriLiteral.stringValue.trim();
-    directive.uriContent = uriContent;
-    if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
+    if (code == UriValidationCode.INVALID_URI) {
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
       return null;
     }
-    try {
-      String encodedUriContent = Uri.encodeFull(uriContent);
-      parseUriWithException(encodedUriContent);
-      Source source = analysisContext.sourceFactory.resolveUri(librarySource, encodedUriContent);
-      if (!analysisContext.exists(source)) {
-        errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
-      }
-      directive.source = source;
-      return source;
-    } on URISyntaxException catch (exception) {
-      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
-    }
-    return null;
+    throw new RuntimeException(message: "Failed to handle validation code: ${code}");
   }
 
   /**
    * The source to be parsed.
    */
   final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
@@ skipping 38 matching lines @@
    * A set containing the sources referenced by 'part' directives.
    */
   Set<Source> _includedSources = new Set<Source>();
 
   /**
    * The errors that were produced by scanning and parsing the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
-   * The prefix of a URI using the `dart-ext` scheme to reference a native code library.
-   */
-  static String _DART_EXT_SCHEME = "dart-ext:";
-
-  /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param tokenStream the head of the token stream used for parsing
    * @param lineInfo the line information associated with the source
    */
   ParseDartTask(InternalAnalysisContext context, this.source, this.modificationTime, this._tokenStream, this.lineInfo) : super(context);
 
@@ skipping 75 matching lines @@
       Parser parser = new Parser(source, errorListener);
       parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
       _unit = parser.parseCompilationUnit(_tokenStream);
       _unit.lineInfo = lineInfo;
       AnalysisContext analysisContext = context;
       for (Directive directive in _unit.directives) {
         if (directive is PartOfDirective) {
           _containsPartOfDirective = true;
         } else {
           _containsNonPartOfDirective = true;
-          if (directive is ExportDirective) {
-            Source exportSource = resolveSource(analysisContext, source, directive, errorListener);
-            if (exportSource != null) {
-              _exportedSources.add(exportSource);
-            }
-          } else if (directive is ImportDirective) {
-            Source importSource = resolveSource(analysisContext, source, directive, errorListener);
-            if (importSource != null) {
-              _importedSources.add(importSource);
-            }
-          } else if (directive is PartDirective) {
-            Source partSource = resolveSource(analysisContext, source, directive, errorListener);
-            if (partSource != null && partSource != source) {
-              _includedSources.add(partSource);
+          if (directive is UriBasedDirective) {
+            Source referencedSource = resolveDirective(analysisContext, source, directive, errorListener);
+            if (referencedSource != null) {
+              if (directive is ExportDirective) {
+                _exportedSources.add(referencedSource);
+              } else if (directive is ImportDirective) {
+                _importedSources.add(referencedSource);
+              } else if (directive is PartDirective) {
+                if (referencedSource != source) {
+                  _includedSources.add(referencedSource);
+                }
+              } else {
+                throw new AnalysisException.con1("${runtimeType.toString()} failed to handle a ${directive.runtimeType.toString()}");
+              }
             }
           }
         }
       }
       _errors = errorListener.getErrorsForSource(source);
     } finally {
       timeCounterParse.stop();
     }
   }
 
@@ skipping 145 matching lines @@
 
   /**
    * Resolves directives in the given [CompilationUnit].
    */
   void _resolveScriptDirectives(CompilationUnit script, AnalysisErrorListener errorListener) {
     if (script == null) {
       return;
     }
     AnalysisContext analysisContext = context;
     for (Directive directive in script.directives) {
-      if (directive is ExportDirective) {
-        ParseDartTask.resolveSource(analysisContext, source, directive, errorListener);
-      } else if (directive is ImportDirective) {
-        ParseDartTask.resolveSource(analysisContext, source, directive, errorListener);
-      } else if (directive is PartDirective) {
-        ParseDartTask.resolveSource(analysisContext, source, directive, errorListener);
+      if (directive is UriBasedDirective) {
+        ParseDartTask.resolveDirective(analysisContext, source, directive, errorListener);
       }
     }
   }
 }
 
 class RecursiveXmlVisitor_ParseHtmlTask_internalPerform extends ht.RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
 
   RecordingErrorListener errorListener;
 
@@ skipping 667 matching lines @@
 
   @override
   void internalPerform() {
     //
     // Build the standard HTML element.
     //
     HtmlUnitBuilder builder = new HtmlUnitBuilder(context);
     _element = builder.buildHtmlElement(source, modificationTime, _unit);
     RecordingErrorListener errorListener = builder.errorListener;
     //
+    // Validate the directives
+    //
+    _unit.accept(new RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(this, errorListener));
+    //
     // Record all resolution errors.
     //
     _resolutionErrors = errorListener.getErrorsForSource(source);
     //
     // Remember the resolved unit.
     //
     _resolvedUnit = _unit;
   }
 }
 
+class RecursiveXmlVisitor_ResolveHtmlTask_internalPerform extends ht.RecursiveXmlVisitor<Object> {
+  final ResolveHtmlTask ResolveHtmlTask_this;
+
+  RecordingErrorListener errorListener;
+
+  RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(this.ResolveHtmlTask_this, this.errorListener) : super();
+
+  @override
+  Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
+    CompilationUnit script = node.script;
+    if (script != null) {
+      GenerateDartErrorsTask.validateDirectives(ResolveHtmlTask_this.context, ResolveHtmlTask_this.source, script, errorListener);
+    }
+    return null;
+  }
+}
+
 /**
  * Instances of the class `ScanDartTask` scan a specific source as a Dart file.
  */
 class ScanDartTask extends AnalysisTask {
   /**
    * The source to be scanned.
    */
   final Source source;
 
   /**
@@ skipping 172 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }