Move unlinked bundle access to _File itself.

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

 // Copyright (c) 2016, 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 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 331 matching lines @@
         file.path.endsWith('pkg/analyzer/lib/src/generated/visitors.dart') ||
         file.path.endsWith('pkg/analyzer/test/generated/constant_test.dart') ||
         file.path.endsWith('pkg/analyzer/test/source/embedder_test.dart')) {
       return new AnalysisResult(
           file.path, file.uri, null, file.contentHash, null, []);
     }
 
     return _logger.run('Compute analysis result for $file', () {
       _LibraryContext libraryContext = _createLibraryContext(file);
       AnalysisContext analysisContext = _createAnalysisContext(libraryContext);
-      analysisContext.setContents(file.source, file.content);
-      // TODO(scheglov) Add support for parts.
-      CompilationUnit resolvedUnit =
-          analysisContext.resolveCompilationUnit2(file.source, file.source);
-      List<AnalysisError> errors = analysisContext.computeErrors(file.source);
-      return new AnalysisResult(file.path, file.uri, file.content,
-          file.contentHash, resolvedUnit, errors);
+      try {
+        analysisContext.setContents(file.source, file.content);
+        // TODO(scheglov) Add support for parts.
+        CompilationUnit resolvedUnit =
+            analysisContext.resolveCompilationUnit2(file.source, file.source);
+        List<AnalysisError> errors = analysisContext.computeErrors(file.source);
+        return new AnalysisResult(file.path, file.uri, file.content,
+            file.contentHash, resolvedUnit, errors);
+      } finally {
+        analysisContext.dispose();
+      }
     });
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
 
     analysisContext.sourceFactory =
         new SourceFactory((_sourceFactory as SourceFactoryImpl).resolvers);
     analysisContext.resultProvider =
@@ skipping 26 matching lines @@
 
         String libraryUriStr = libraryUri.toString();
         _LibraryNode node = nodes[libraryUriStr];
         if (node == null) {
           node = new _LibraryNode(this, nodes, libraryUri);
           nodes[libraryUriStr] = node;
 
           // Append the defining unit.
           _ReferencedUris referenced;
           {
-            PackageBundle bundle = _getUnlinked(libraryFile);
+            PackageBundle bundle = libraryFile.unlinked;
             UnlinkedUnit unlinked = bundle.unlinkedUnits.single;
             referenced = new _ReferencedUris(unlinked);
             node.unlinkedBundles.add(bundle);
             _addToStoreUnlinked(store, libraryUriStr, unlinked);
           }
 
           // Append parts.
           for (String uri in referenced.parted) {
             _File file = libraryFile.resolveUri(uri);
-            PackageBundle bundle = _getUnlinked(file);
+            PackageBundle bundle = file.unlinked;
             UnlinkedUnit unlinked = bundle.unlinkedUnits.single;
             node.unlinkedBundles.add(bundle);
             _addToStoreUnlinked(store, file.uri.toString(), unlinked);
           }
 
           // Create nodes for referenced libraries.
           for (String uri in referenced.imported) {
             _File file = libraryFile.resolveUri(uri);
             createLibraryNodes(file);
           }
@@ skipping 68 matching lines @@
    * Return the [_File] for the given [path] in [_sourceFactory].
    */
   _File _fileForPath(String path) {
     Source fileSource = _resourceProvider.getFile(path).createSource();
     Uri uri = _sourceFactory.restoreUri(fileSource);
     Source source = _resourceProvider.getFile(path).createSource(uri);
     return new _File(this, source);
   }
 
   /**
-   * Return the unlinked bundle of [file] for the current file state, or `null`.
-   */
-  PackageBundle _getCurrentUnlinked(_File file) {
-    String key = '${file.currentContentHash}.unlinked';
-    List<int> bytes = _byteStore.get(key);
-    return bytes != null ? new PackageBundle.fromBuffer(bytes) : null;
-  }
-
-  /**
-   * Return the unlinked bundle of [file] for the current file state.
-   *
-   * Return [_getCurrentUnlinked] or read the [file] content is read, compute
-   * the content hash and update the current file state accordingly. Parse the
-   * content into the [CompilationUnit] and serialize into a new unlinked
-   * bundle. The bundle is then put into the [_byteStore] and returned.
-   */
-  PackageBundle _getUnlinked(_File file) {
-    // By accessing 'contentHash' we ensure that the current file state
-    // has some version of the file content hash, so we will be able to
-    // use it to attempt to get the current unlinked bundle.
-    String key = '${file.contentHash}.unlinked';
-    return _getCurrentUnlinked(file) ??
-        _logger.run('Create unlinked for $file', () {
-          UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(file.unit);
-          PackageBundleAssembler assembler = new PackageBundleAssembler();
-          assembler.addUnlinkedUnitWithHash(
-              file.uri.toString(), unlinkedUnit, key);
-          List<int> bytes = assembler.assemble().toBuffer();
-          _byteStore.put(key, bytes);
-          return new PackageBundle.fromBuffer(bytes);
-        });
-  }
-
-  /**
    * Verify the API signatures for the changed files, and decide which linked
    * libraries should be invalidated, and files reanalyzed.
    *
    * TODO(scheglov) I see that adding a local var changes (full) API signature.
    */
   void _verifyUnlinkedSignatureOfChangedFiles() {
     if (_filesToVerifyUnlinkedSignature.isEmpty) {
       return;
     }
     int numOfFiles = _filesToVerifyUnlinkedSignature.length;
     _logger.run('Verify API signatures of $numOfFiles files', () {
       for (String path in _filesToVerifyUnlinkedSignature) {
         _File file = _fileForPath(path);
         // Get the existing old API signature, maybe null.
-        String oldSignature = _getCurrentUnlinked(file)?.apiSignature;
+        String oldSignature = file.currentUnlinked?.apiSignature;
         // Clear the content hash cache, so force the file reading.
         _fileContentHashMap.remove(path);
         // Compute the new API signature.
-        String newSignature = _getUnlinked(file).apiSignature;
+        String newSignature = file.unlinked.apiSignature;
         // If the signatures are not the same, then potentially every linked
         // library is inconsistent and should be recomputed, and every explicit
         // file has inconsistent analysis results which also should be recomputed.
         if (oldSignature != newSignature) {
           _logger.writeln('API signature mismatch found for $file.');
           _dependencySignatureMap.clear();
           _filesToAnalyze.addAll(_explicitFiles);
           // Stop the verification, and restart analysis.
           break;
         }
@@ skipping 193 matching lines @@
   }
 
   /**
    * Return the hash of the file content in the current file state, or `null`
    * if the current file state does not know the current file content hash.
    */
   String get currentContentHash {
     return driver._fileContentHashMap[path];
   }
 
+  /**
+   * Return the unlinked bundle for the current file state, or `null`.
+   */
+  PackageBundle get currentUnlinked {
+    String hash = currentContentHash;
+    if (hash != null) {
+      String key = '$hash.unlinked';
+      List<int> bytes = driver._byteStore.get(key);
+      if (bytes != null) {
+        return new PackageBundle.fromBuffer(bytes);
+      }
+    }
+    return null;
+  }
+
   String get path => source.fullName;
 
   /**
    * Return the unresolved [CompilationUnit] of the file.
    *
    * Performing resolution and computing errors is done in a separate analysis
    * context. In the future we might push the existing unresolved unit into the
    * analysis context, so at some point the unit might become resolved.
    */
   CompilationUnit get unit {
-    AnalysisErrorListener errorListener = AnalysisErrorListener.NULL_LISTENER;
+    if (_unit == null) {
+      AnalysisErrorListener errorListener = AnalysisErrorListener.NULL_LISTENER;
 
-    CharSequenceReader reader = new CharSequenceReader(content);
-    Scanner scanner = new Scanner(source, reader, errorListener);
-    scanner.scanGenericMethodComments = driver._analysisOptions.strongMode;
-    Token token = scanner.tokenize();
-    LineInfo lineInfo = new LineInfo(scanner.lineStarts);
+      CharSequenceReader reader = new CharSequenceReader(content);
+      Scanner scanner = new Scanner(source, reader, errorListener);
+      scanner.scanGenericMethodComments = driver._analysisOptions.strongMode;
+      Token token = scanner.tokenize();
+      LineInfo lineInfo = new LineInfo(scanner.lineStarts);
 
-    Parser parser = new Parser(source, errorListener);
-    parser.parseGenericMethodComments = driver._analysisOptions.strongMode;
-    _unit = parser.parseCompilationUnit(token);
-    _unit.lineInfo = lineInfo;
+      Parser parser = new Parser(source, errorListener);
+      parser.parseGenericMethodComments = driver._analysisOptions.strongMode;
+      _unit = parser.parseCompilationUnit(token);
+      _unit.lineInfo = lineInfo;
+    }
+    return _unit;
+  }
 
-    return _unit;
+  /**
+   * Return the unlinked bundle for the current file state.
+   *
+   * If the file [contentHash] is cached, try to load the bundle with this
+   * hash. Otherwise, read the content, compute the new hash and try to find
+   * the existing bundle, or parse the content and compute a new bundle.
+   */
+  PackageBundle get unlinked {
+    String key = '$contentHash.unlinked';
+    List<int> bytes = driver._byteStore.get(key);
+    if (bytes == null) {
+      driver._logger.run('Create unlinked for $this', () {
+        UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
+        PackageBundleAssembler assembler = new PackageBundleAssembler();
+        assembler.addUnlinkedUnitWithHash(
+            uri.toString(), unlinkedUnit, contentHash);
+        bytes = assembler.assemble().toBuffer();
+        driver._byteStore.put(key, bytes);
+      });
+    }
+    return new PackageBundle.fromBuffer(bytes);
   }
 
   Uri get uri => source.uri;
 
   /**
    * Return the [_File] for the [uri] referenced in this file.
    */
   _File resolveUri(String uri) {
     // TODO(scheglov) Consider removing this caching after implementing other
     // optimizations, e.g. changeFile() optimization.
@@ skipping 170 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }