Fixes for URI and Object completions with the new driver.

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:typed_data';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/error/error.dart';
@@ skipping 496 matching lines @@
                           correction: error.correction))
                       .toList())
               .toBuffer();
           String key = _getResolvedUnitKey(libraryFile, file);
           _byteStore.put(key, bytes);
         }
 
         // Return the result, full or partial.
         _logger.writeln('Computed new analysis result.');
         return new AnalysisResult(
+            _sourceFactory,
             file.path,
             file.uri,
             withUnit ? file.content : null,
             file.contentHash,
             file.lineInfo,
             resolvedUnit,
             errors);
       } finally {
         analysisContext.dispose();
       }
@@ skipping 136 matching lines @@
       var unit = new AnalysisDriverResolvedUnit.fromBuffer(bytes);
       List<AnalysisError> errors = unit.errors
           .map((error) => new AnalysisError.forValues(
               file.source,
               error.offset,
               error.length,
               errorCodeByUniqueName(error.uniqueName),
               error.message,
               error.correction))
           .toList();
-      return new AnalysisResult(file.path, file.uri, null, file.contentHash,
-          file.lineInfo, null, errors);
+      return new AnalysisResult(_sourceFactory, file.path, file.uri, null,
+          file.contentHash, file.lineInfo, null, errors);
     }
     return null;
   }
 
   /**
    * Return the key to store fully resolved results for the [file] in the
    * [library] into the cache. Return `null` if the dependency signature is
    * not known yet.
    */
   String _getResolvedUnitKey(FileState library, FileState file) {
@@ skipping 261 matching lines @@
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. All referenced elements, even
  * external ones, are also self-consistent. But none of the results is
  * guaranteed to be consistent with the state of the files.
  *
  * Every result is independent, and is not guaranteed to be consistent with
  * any previously returned result, even inside of the same library.
  */
 class AnalysisResult {
   /**
+   * The [SourceFactory] with which the file was analyzed.
+   */
+  final SourceFactory sourceFactory;
+
+  /**
    * The path of the analysed file, absolute and normalized.
    */
   final String path;
 
   /**
    * The URI of the file that corresponded to the [path] in the used
    * [SourceFactory] at some point. Is it not guaranteed to be still consistent
    * to the [path], and provided as FYI.
    */
   final Uri uri;
@@ skipping 16 matching lines @@
   /**
    * The fully resolved compilation unit for the [content].
    */
   final CompilationUnit unit;
 
   /**
    * The full list of computed analysis errors, both syntactic and semantic.
    */
   final List<AnalysisError> errors;
 
-  AnalysisResult(this.path, this.uri, this.content, this.contentHash,
-      this.lineInfo, this.unit, this.errors);
+  AnalysisResult(this.sourceFactory, this.path, this.uri, this.content,
+      this.contentHash, this.lineInfo, this.unit, this.errors);
 }
 
 /**
  * The result of parsing of a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. But none of the results is
  * guaranteed to be consistent with the state of the files.
  */
 class ParseResult {
@@ skipping 166 matching lines @@
         }
       }
 
       appendDependencies(file);
     }
   }
 
   @override
   String toString() => uri.toString();
 }