Resolve Library/Part/PartOf/Directive(s) in AST without tasks.

pkg/analyzer/lib/src/dart/analysis/analysis_impl.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/constant/evaluation.dart';
 import 'package:analyzer/src/dart/constant/utilities.dart';
-import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/pending_error.dart';
 import 'package:analyzer/src/generated/declaration_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
@@ skipping 11 matching lines @@
   final AnalysisOptions _analysisOptions;
   final DeclaredVariables _declaredVariables;
   final SourceFactory _sourceFactory;
   final FileSystemState _fsState;
   final SummaryDataStore _store;
   final FileState _library;
 
   TypeProvider _typeProvider;
   AnalysisContextImpl _context;
   StoreBasedSummaryResynthesizer _resynthesizer;
+  LibraryElement _libraryElement;
 
   final Map<FileState, RecordingErrorListener> _errorListeners = {};
   final Map<FileState, ErrorReporter> _errorReporters = {};
   final List<UsedImportedElements> _usedImportedElementsList = [];
   final List<UsedLocalElements> _usedLocalElementsList = [];
   final List<ConstantEvaluationTarget> _constants = [];
 
   AnalyzerImpl(this._analysisOptions, this._declaredVariables,
       this._sourceFactory, this._fsState, this._store, this._library);
 
   /**
    * Compute analysis results for all units of the library.
    */
   Map<FileState, UnitAnalysisResult> analyze() {
     Map<FileState, CompilationUnit> units = {};
 
     // Parse all files.
     units[_library] = _parse(_library);
     for (FileState part in _library.partedFiles) {
       units[part] = _parse(part);
     }
 
-    // Resolve directives.
+    // Resolve URIs in directives to corresponding sources.
     units.forEach((file, unit) {
       _resolveUriBasedDirectives(file, unit);
     });
 
     _createAnalysisContext();
 
     try {
       _resynthesizer = new StoreBasedSummaryResynthesizer(
           _context, _sourceFactory, _analysisOptions.strongMode, _store);
       _typeProvider = _resynthesizer.typeProvider;
       _context.typeProvider = _typeProvider;
 
+      _libraryElement = _resynthesizer.getLibraryElement(_library.uriStr);
+
+      _resolveDirectives(units);
+
       units.forEach((file, unit) {
         _resolveFile(file, unit);
       });
 
       _computeConstants();
 
       units.forEach((file, unit) {
-        LibraryElement libraryElement = unit.element.library;
         {
-          var visitor = new GatherUsedLocalElementsVisitor(libraryElement);
+          var visitor = new GatherUsedLocalElementsVisitor(_libraryElement);
           unit.accept(visitor);
           _usedLocalElementsList.add(visitor.usedElements);
         }
         {
-          var visitor = new GatherUsedImportedElementsVisitor(libraryElement);
+          var visitor = new GatherUsedImportedElementsVisitor(_libraryElement);
           unit.accept(visitor);
           _usedImportedElementsList.add(visitor.usedElements);
         }
       });
 
       units.forEach((file, unit) {
         _computeVerifyErrorsAndHints(file, unit);
       });
     } finally {
       _context.dispose();
@@ skipping 27 matching lines @@
     for (_ConstantNode node in nodes) {
       if (!node.isEvaluated) {
         new _ConstantWalker(evaluationEngine).walk(node);
       }
     }
   }
 
   void _computeVerifyErrorsAndHints(FileState file, CompilationUnit unit) {
     RecordingErrorListener errorListener = _getErrorListener(file);
     CompilationUnitElement unitElement = unit.element;
-    LibraryElement libraryElement = unitElement.library;
 
     //
     // Use the ErrorVerifier to compute errors.
     //
     List<PendingError> pendingErrors;
     {
       RequiredConstantsComputer computer =
           new RequiredConstantsComputer(file.source);
       unit.accept(computer);
       pendingErrors = computer.pendingErrors;
@@ skipping 17 matching lines @@
 
     //
     // Validate the directives.
     //
     _validateUriBasedDirectives(file, unit);
 
     //
     // Use the ConstantVerifier to compute errors.
     //
     ConstantVerifier constantVerifier = new ConstantVerifier(
-        errorReporter, libraryElement, _typeProvider, _declaredVariables);
+        errorReporter, _libraryElement, _typeProvider, _declaredVariables);
     unit.accept(constantVerifier);
 
     //
     // Use the ErrorVerifier to compute errors.
     //
     ErrorVerifier errorVerifier = new ErrorVerifier(
         errorReporter,
-        libraryElement,
+        _libraryElement,
         _typeProvider,
-        new InheritanceManager(libraryElement),
+        new InheritanceManager(_libraryElement),
         _analysisOptions.enableSuperMixins);
     unit.accept(errorVerifier);
 
     //
     // Convert the pending errors into actual errors.
     //
     for (PendingError pendingError in pendingErrors) {
       errorListener.onError(pendingError.toAnalysisError());
     }
 
     //
     // Find dead code.
     //
     unit.accept(
         new DeadCodeVerifier(errorReporter, typeSystem: _context.typeSystem));
 
     // Dart2js analysis.
     if (_analysisOptions.dart2jsHint) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
 
     InheritanceManager inheritanceManager = new InheritanceManager(
-        libraryElement,
+        _libraryElement,
         includeAbstractFromSuperclasses: true);
 
     unit.accept(new BestPracticesVerifier(
-        errorReporter, _typeProvider, libraryElement, inheritanceManager,
+        errorReporter, _typeProvider, _libraryElement, inheritanceManager,
         typeSystem: _context.typeSystem));
 
     unit.accept(new OverrideVerifier(errorReporter, inheritanceManager));
 
     new ToDoFinder(errorReporter).findIn(unit);
 
     // Verify imports.
     {
       ImportsVerifier verifier = new ImportsVerifier();
       verifier.addImports(unit);
       _usedImportedElementsList.forEach(verifier.removeUsedElements);
       ErrorReporter errorReporter = _getErrorReporter(file);
       verifier.generateDuplicateImportHints(errorReporter);
       verifier.generateUnusedImportHints(errorReporter);
       verifier.generateUnusedShownNameHints(errorReporter);
     }
 
     {
       GatherUsedLocalElementsVisitor visitor =
-          new GatherUsedLocalElementsVisitor(libraryElement);
+          new GatherUsedLocalElementsVisitor(_libraryElement);
       unit.accept(visitor);
     }
 
     // Unused local elements.
     {
       UsedLocalElements usedElements =
           new UsedLocalElements.merge(_usedLocalElementsList);
       UnusedLocalElementsVerifier visitor =
           new UnusedLocalElementsVerifier(errorListener, usedElements);
       unitElement.accept(visitor);
@@ skipping 14 matching lines @@
       _errorListeners.putIfAbsent(file, () => new RecordingErrorListener());
 
   ErrorReporter _getErrorReporter(FileState file) {
     return _errorReporters.putIfAbsent(file, () {
       RecordingErrorListener listener = _getErrorListener(file);
       return new ErrorReporter(listener, file.source);
     });
   }
 
   /**
+   * Return the name of the library that the given part is declared to be a
+   * part of, or `null` if the part does not contain a part-of directive.
+   */
+  _NameOrSource _getPartLibraryNameOrUri(Source partSource,
+      CompilationUnit partUnit, List<Directive> directivesToResolve) {
+    for (Directive directive in partUnit.directives) {
+      if (directive is PartOfDirective) {
+        directivesToResolve.add(directive);
+        LibraryIdentifier libraryName = directive.libraryName;
+        if (libraryName != null) {
+          return new _NameOrSource(libraryName.name, null);
+        }
+        String uri = directive.uri?.stringValue;
+        if (uri != null) {
+          Source librarySource = _sourceFactory.resolveUri(partSource, uri);
+          if (librarySource != null) {
+            return new _NameOrSource(null, librarySource);
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return a new parsed unresolved [CompilationUnit].
    */
   CompilationUnit _parse(FileState file) {
     RecordingErrorListener errorListener = _getErrorListener(file);
 
     CharSequenceReader reader = new CharSequenceReader(file.content);
     Scanner scanner = new Scanner(file.source, reader, errorListener);
     scanner.scanGenericMethodComments = _analysisOptions.strongMode;
     Token token = scanner.tokenize();
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
 
     Parser parser = new Parser(file.source, errorListener);
     parser.parseGenericMethodComments = _analysisOptions.strongMode;
+    parser.enableUriInPartOf = _analysisOptions.enableUriInPartOf;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = lineInfo;
     return unit;
   }
 
+  void _resolveDirectives(Map<FileState, CompilationUnit> units) {
+    CompilationUnit definingCompilationUnit = units[_library];
+
+    var uriToElement = <Uri, CompilationUnitElement>{};
+    for (CompilationUnitElement partElement in _libraryElement.units) {
+      uriToElement[partElement.source.uri] = partElement;
+    }
+
+    var sourceToUnit = <Source, CompilationUnit>{};
+    units.forEach((file, unit) {
+      Source source = file.source;
+      unit.element = uriToElement[source.uri];
+      sourceToUnit[source] = unit;
+    });
+
+    ErrorReporter libraryErrorReporter = _getErrorReporter(_library);
+    LibraryIdentifier libraryNameNode = null;
+    bool hasPartDirective = false;
+    var seenPartSources = new Set<Source>();
+    var directivesToResolve = <Directive>[];
+    for (Directive directive in definingCompilationUnit.directives) {
+      if (directive is LibraryDirective) {
+        libraryNameNode = directive.name;
+        directivesToResolve.add(directive);
+      } else if (directive is PartDirective) {
+        hasPartDirective = true;
+        StringLiteral partUri = directive.uri;
+        Source partSource = directive.uriSource;
+        CompilationUnit partUnit = sourceToUnit[partSource];
+        if (partUnit != null) {
+          directive.element = partUnit.element;
+          //
+          // Validate that the part source is unique in the library.
+          //
+          if (!seenPartSources.add(partSource)) {
+            libraryErrorReporter.reportErrorForNode(
+                CompileTimeErrorCode.DUPLICATE_PART, partUri, [partSource.uri]);
+          }
+          //
+          // Validate that the part contains a part-of directive with the same
+          // name as the library.
+          //
+          if (_context.exists(partSource)) {
+            _NameOrSource nameOrSource = _getPartLibraryNameOrUri(
+                partSource, partUnit, directivesToResolve);
+            if (nameOrSource == null) {
+              libraryErrorReporter.reportErrorForNode(
+                  CompileTimeErrorCode.PART_OF_NON_PART,
+                  partUri,
+                  [partUri.toSource()]);
+            } else {
+              String name = nameOrSource.name;
+              if (name != null) {
+                if (libraryNameNode != null && libraryNameNode.name != name) {
+                  libraryErrorReporter.reportErrorForNode(
+                      StaticWarningCode.PART_OF_DIFFERENT_LIBRARY,
+                      partUri,
+                      [libraryNameNode.name, name]);
+                }
+              } else {
+                Source source = nameOrSource.source;
+                if (source != _library.source) {
+                  libraryErrorReporter.reportErrorForNode(
+                      StaticWarningCode.PART_OF_DIFFERENT_LIBRARY,
+                      partUri,
+                      [_library.uriStr, source.uri]);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (hasPartDirective && libraryNameNode == null) {
+      libraryErrorReporter.reportErrorForOffset(
+          ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, 0, 0);
+    }
+
+    //
+    // Resolve the relevant directives to the library element.
+    //
+    for (Directive directive in directivesToResolve) {
+      directive.element = _libraryElement;
+    }
+
+    {
+      // TODO(scheglov) fill these maps?
+      DirectiveResolver resolver = new DirectiveResolver({}, {}, {});
+      definingCompilationUnit.accept(resolver);
+    }
+  }
+
   void _resolveFile(FileState file, CompilationUnit unit) {
     RecordingErrorListener errorListener = _getErrorListener(file);
 
-    String libraryUri = _library.uri.toString();
-    String unitUri = file.uri.toString();
-    CompilationUnitElement unitElement = _resynthesizer.getElement(
-        new ElementLocationImpl.con3(<String>[libraryUri, unitUri]));
-    LibraryElement libraryElement = unitElement.library;
+    CompilationUnitElement unitElement = unit.element;
+    Source source = file.source;
 
     // TODO(scheglov) Hack: set types for top-level variables
     // Otherwise TypeResolverVisitor will set declared types, and because we
     // don't run InferStaticVariableTypeTask, we will stuck with these declared
     // types. And we don't need to run this task - resynthesized elements have
     // inferred types.
     for (var e in unitElement.topLevelVariables) {
       if (!e.isSynthetic) {
         e.type;
       }
     }
 
     new DeclarationResolver().resolve(unit, unitElement);
 
-    if (file == _library) {
-      // TODO(scheglov) fill these maps?
-      DirectiveResolver resolver = new DirectiveResolver({}, {}, {});
-      unit.accept(resolver);
-    }
-
     // TODO(scheglov) remove EnumMemberBuilder class
 
     new TypeParameterBoundsResolver(
-            _typeProvider, libraryElement, unitElement.source, errorListener)
+            _typeProvider, _libraryElement, source, errorListener)
         .resolveTypeBounds(unit);
 
     unit.accept(new TypeResolverVisitor(
-        libraryElement, unitElement.source, _typeProvider, errorListener));
+        _libraryElement, source, _typeProvider, errorListener));
 
-    LibraryScope libraryScope = new LibraryScope(libraryElement);
+    LibraryScope libraryScope = new LibraryScope(_libraryElement);
     unit.accept(new VariableResolverVisitor(
-        libraryElement, unitElement.source, _typeProvider, errorListener,
+        _libraryElement, source, _typeProvider, errorListener,
         nameScope: libraryScope));
 
-    unit.accept(new PartialResolverVisitor(libraryElement, unitElement.source,
+    unit.accept(new PartialResolverVisitor(_libraryElement, source,
         _typeProvider, AnalysisErrorListener.NULL_LISTENER));
 
     // Nothing for RESOLVED_UNIT8?
     // Nothing for RESOLVED_UNIT9?
     // Nothing for RESOLVED_UNIT10?
 
     unit.accept(new ResolverVisitor(
-        libraryElement, unitElement.source, _typeProvider, errorListener));
+        _libraryElement, source, _typeProvider, errorListener));
 
     //
     // Find constants to compute.
     //
     {
       ConstantFinder constantFinder = new ConstantFinder();
       unit.accept(constantFinder);
       _constants.addAll(constantFinder.constantsToCompute);
     }
   }
@@ skipping 202 matching lines @@
   @override
   String setContents(Source source, String contents) {
     throw new UnimplementedError();
   }
 
   FileState _getFileForSource(Source source) {
     String path = source.fullName;
     return fsState.getFileForPath(path);
   }
 }
+
+/**
+ * Either the name or the source associated with a part-of directive.
+ */
+class _NameOrSource {
+  final String name;
+  final Source source;
+  _NameOrSource(this.name, this.source);
+}