Emulate compiling a source file in the context of an existing library. Add --debugger-compile flag …

pkg/dev_compiler/web/web_command.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.
 @JS()
 library dev_compiler.web.web_command;
 
 import 'dart:async';
+import 'dart:convert';
 import 'dart:html' show HttpRequest;
-import 'dart:convert' show BASE64;
 
+import 'package:analyzer/dart/element/element.dart'
+    show
+        LibraryElement,
+        ImportElement,
+        ShowElementCombinator,
+        HideElementCombinator;
 import 'package:analyzer/file_system/file_system.dart' show ResourceUriResolver;
 import 'package:analyzer/file_system/memory_file_system.dart'
     show MemoryResourceProvider;
 import 'package:analyzer/src/context/context.dart' show AnalysisContextImpl;
 import 'package:analyzer/src/generated/source.dart' show DartUriResolver;
 import 'package:analyzer/src/summary/idl.dart' show PackageBundle;
 import 'package:analyzer/src/summary/package_bundle_reader.dart'
     show
         SummaryDataStore,
         InSummaryUriResolver,
         InputPackagesResultProvider,
         InSummarySource;
+import 'package:analyzer/src/dart/resolver/scope.dart' show Scope;
 import 'package:analyzer/src/summary/summary_sdk.dart' show SummaryBasedDartSdk;
 
 import 'package:args/command_runner.dart';
 
 import 'package:dev_compiler/src/analyzer/context.dart' show AnalyzerOptions;
 import 'package:dev_compiler/src/compiler/compiler.dart'
     show BuildUnit, CompilerOptions, JSModuleFile, ModuleCompiler;
 
 import 'package:dev_compiler/src/compiler/module_builder.dart';
 import 'package:js/js.dart';
+import 'package:path/path.dart' as path;
 
 typedef void MessageHandler(Object message);
 
 @JS()
 @anonymous
 class CompileResult {
   external factory CompileResult(
       {String code, List<String> errors, bool isValid});
 }
 
-typedef CompileResult CompileModule(
-    String code, String libraryName, String fileName);
+typedef CompileModule(String imports, String body, String libraryName,
+    String existingLibrary, String fileName);
 
 /// The command for invoking the modular compiler.
 class WebCompileCommand extends Command {
   get name => 'compile';
 
   get description => 'Compile a set of Dart files into a JavaScript module.';
   final MessageHandler messageHandler;
 
   WebCompileCommand({MessageHandler messageHandler})
       : this.messageHandler = messageHandler ?? print {
@@ skipping 40 matching lines @@
         true, packageBundle, resourceProvider);
     var sdkResolver = new DartUriResolver(webDartSdk);
 
     var summaryDataStore = new SummaryDataStore([]);
     for (var i = 0; i < summaryBytes.length; i++) {
       var bytes = summaryBytes[i];
       var url = summaryUrls[i];
       var summaryBundle = new PackageBundle.fromBuffer(bytes);
       summaryDataStore.addBundle(url, summaryBundle);
     }
-    var summaryResolver = new InSummaryUriResolver(resourceProvider, summaryDataStore);
+    var summaryResolver =
+        new InSummaryUriResolver(resourceProvider, summaryDataStore);
 
     var fileResolvers = [summaryResolver, resourceUriResolver];
 
     var compiler = new ModuleCompiler(
         new AnalyzerOptions(dartSdkPath: '/dart-sdk'),
         sdkResolver: sdkResolver,
         fileResolvers: fileResolvers,
         resourceProvider: resourceProvider);
 
-    (compiler.context as AnalysisContextImpl).resultProvider =
+    var context = compiler.context as AnalysisContextImpl;
+    context.resultProvider =
         new InputPackagesResultProvider(compiler.context, summaryDataStore);
 
     var compilerOptions = new CompilerOptions.fromArguments(argResults);
 
-    CompileModule compileFn =
-        (String sourceCode, String libraryName, String fileName) {
+    CompileModule compileFn = (String imports, String body, String libraryName,
+        String existingLibrary, String fileName) {
       // Create a new virtual File that contains the given Dart source.
-      resourceProvider.newFile("/$fileName", sourceCode);
+      String sourceCode;
+      if (existingLibrary == null) {
+        sourceCode = imports + body;
+      } else {
+        var dir = path.dirname(existingLibrary);
+        // Need to pull in all the imports from the existing library and
+        // re-export all privates as privates in this library.
+        var source = context.sourceFactory.forUri(existingLibrary);
+        if (source == null) {
+          throw "Unable to load source for library $existingLibrary";
+        }
 
-      var unit = new BuildUnit(
-          libraryName, "", ["file:///$fileName"], _moduleForLibrary);
+        LibraryElement libraryElement = context.computeLibraryElement(source);
+        if (libraryElement == null) {
+          throw "Unable to get library element.";

[Jennifer Messerly, 2016/10/18 18:46:01]

do you know in what context this actually happens? or is it just defensive?
either way a comment would be helpful. 

In general throwing strings isn't great from a style perspective. Some kind of
Error (if it indicates a programming error) or an Exception (if it indicates a
runtime failure that can happen) is better.

+        }
+        var sb = new StringBuffer(imports);
+        sb.write('\n');
+
+        // We set the private name prefix for scope resolution to an invalid
+        // character code so that the analyzer ignores normal Dart private
+        // scoping rules for top level names allowing REPL users to access
+        // privates in arbitrary libraries. The downside of this scheme is it is
+        // possible to get errors if privates in the current library and
+        // imported libraries happen to have exactly the same name.
+        Scope.PRIVATE_NAME_PREFIX = -1;

[Jennifer Messerly, 2016/10/18 18:46:01]

Interesting. It seems better to add a feature explicitly to pkg/analyzer?
Otherwise I'd worry this could get broken or have other unintended effects.

[Brian Wilkerson, 2016/10/18 19:16:44]

I agree, this seems brittle. (I can't even guarantee that all code that deals
with private names uses this constant.) Unfortunately, adding the feature
probably isn't trivial (even though it's the better way to solve this).

What are the effects of not doing this? Obviously we'll get errors generated,
but does analyzer resolve the private name to what it would have been, or does
it just not resolve it?

+
+        // We emulate running code in the context of an existing library by
+        // importing that library and all libraries it imports.
+        sb.write('import ${JSON.encode(existingLibrary)};\n');
+
+        for (ImportElement importElement in libraryElement.imports) {
+          if (importElement.uri == null) continue;
+          var uri = importElement.uri;
+          // dart: and package: uris are not relative but the path package
+          // thinks they are. We have to provide absolute uris as our library
+          // has a different directory than the library we are pretending to be.

[Brian Wilkerson, 2016/10/18 19:16:44]

It might be better to get the URI of the imported library rather than
manipulating strings. I'm thinking of something like:

  importElement.importedLibrary.definingCompilationUnit.source.uri

but it's possible that that won't work well for your use case.

+          if (path.isRelative(uri) &&
+              !uri.startsWith('package:') &&
+              !uri.startsWith('dart:')) {
+            uri = path.normalize(path.join(dir, uri));
+          }
+          sb.write('import ${JSON.encode(uri)}');
+          if (importElement.prefix != null)
+            sb.write(' as ${importElement.prefix.name}');
+          for (var combinator in importElement.combinators) {
+            if (combinator is ShowElementCombinator) {
+              sb.write(' show ${combinator.shownNames.join(', ')}');
+            } else if (combinator is HideElementCombinator) {
+              sb.write(' hide ${combinator.hiddenNames.join(', ')}');
+            } else {
+              throw 'Unexpected element combinator';
+            }
+          }
+          sb.write(';\n');
+        }
+        sb.write(body);
+        sourceCode = sb.toString();
+      }
+      resourceProvider.newFile(fileName, sourceCode);
+
+      var unit = new BuildUnit(libraryName, "", [fileName], _moduleForLibrary);
 
       JSModuleFile module = compiler.compile(unit, compilerOptions);
 
       var moduleCode = module.isValid
           ? module
-              .getCode(ModuleFormat.legacy, false, unit.name, unit.name + '.map')
+              .getCode(ModuleFormat.legacy, true, unit.name, unit.name + '.map')
               .code
           : '';
 
       return new CompileResult(
           code: moduleCode, isValid: module.isValid, errors: module.errors);
     };
 
     return allowInterop(compileFn);
   }
 }
 
 // Given path, determine corresponding dart library.
 String _moduleForLibrary(source) {
   if (source is InSummarySource) {
     return source.summaryPath.substring(1).replaceAll('.api.ds', '');
   }
   return source.toString().substring(1).replaceAll('.dart', '');
 }
 
 /// Thrown when the input source code has errors.
 class CompileErrorException implements Exception {
   toString() => '\nPlease fix all errors before compiling (warnings are okay).';
 }