Make parts hermetic, fixes #531

lib/src/compiler/compiler.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:collection' show HashSet;
 import 'package:args/args.dart' show ArgParser, ArgResults;
 import 'package:analyzer/analyzer.dart'
-    show AnalysisError, CompilationUnit, ErrorSeverity;
+    show AnalysisError, CompilationUnit, CompileTimeErrorCode, ErrorSeverity;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/java_engine.dart' show AnalysisException;
 import 'package:analyzer/src/generated/source_io.dart' show Source, SourceKind;
 import 'package:func/func.dart' show Func1;
 import 'package:path/path.dart' as path;
 
 import '../analyzer/context.dart'
     show AnalyzerOptions, createAnalysisContextWithSources;
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'code_generator.dart' show CodeGenerator;
@@ skipping 27 matching lines @@
 
   /// Compiles a single Dart build unit into a JavaScript module.
   ///
   /// *Warning* - this may require resolving the entire world.
   /// If that is not desired, the analysis context must be pre-configured using
   /// summaries before calling this method.
   JSModuleFile compile(BuildUnit unit, CompilerOptions options) {
     var trees = <CompilationUnit>[];
     var errors = <AnalysisError>[];
 
+    // Validate that all parts were explicitly passed in.
+    // If not, it's an error.
+    var explicitParts = new HashSet<Source>();
+    var implicitParts = new HashSet<Source>();

[Paul Berry, 2016/04/28 20:12:33]

Nit: this is a confusing name.  It seems to imply that we are binning parts into
two categories (those that are explicit and those that are implicit), so no part
should ever wind up in both sets.  But that's not what's happening; under normal
conditions both sets will be equal.

Consider renaming to something like `usedParts`.

[Jennifer Messerly, 2016/04/28 20:18:23]

good idea, done

     for (var sourcePath in unit.sources) {
       var sourceUri = Uri.parse(sourcePath);
       if (sourceUri.scheme == '') {
         sourceUri = path.toUri(path.absolute(sourcePath));
       }
       Source source = context.sourceFactory.forUri(sourceUri.toString());
       if (source == null) {
         throw new AnalysisException('could not create a source for $sourcePath.'
             ' The file name is in the wrong format or was not found.');
       }
 
       // Ignore parts. They need to be handled in the context of their library.
-      if (context.getKindOf(source) == SourceKind.PART) {
+      if (context.computeKindOf(source) == SourceKind.PART) {
+        explicitParts.add(source);
         continue;
       }
 
       var resolvedTree = context.resolveCompilationUnit2(source, source);
       trees.add(resolvedTree);
       errors.addAll(context.computeErrors(source));
 
       var library = resolvedTree.element.library;
       for (var part in library.parts) {
+        implicitParts.add(part.source);
         trees.add(context.resolveCompilationUnit(part.source, library));
         errors.addAll(context.computeErrors(part.source));
       }
     }
 
+    // Check if all parts were explicitly passed in.
+    // Also verify all explicitly parts were used.
+    var missingParts = implicitParts.difference(explicitParts);
+    var unusedParts = explicitParts.difference(implicitParts);
+    errors.addAll(missingParts
+        .map((s) => new AnalysisError(s, 0, 0, missingPartErrorCode)));
+    errors.addAll(unusedParts
+        .map((s) => new AnalysisError(s, 0, 0, unusedPartErrorCode)));
+
     sortErrors(context, errors);
     var messages = <String>[];
     for (var e in errors) {
       var m = formatError(context, e);
       if (m != null) messages.add(m);
     }
 
     if (!options.unsafeForceCompile &&
         errors.any((e) => errorSeverity(context, e) == ErrorSeverity.ERROR)) {
       return new JSModuleFile.invalid(unit.name, messages);
@@ skipping 170 matching lines @@
 
     var map = new Map.from(this.sourceMap);
     List list = new List.from(map['sources']);
     map['sources'] = list;
     for (int i = 0; i < list.length; i++) {
       list[i] = path.relative(list[i], from: dir);
     }
     return map;
   }
 }
+
+/// (Public for tests) the error code used when a part is missing.
+final missingPartErrorCode = const CompileTimeErrorCode(
+    'MISSING_PART', 'The part was not supplied as an input to the compiler.');
+
+/// (Public for tests) the error code used when a part is unused.
+final unusedPartErrorCode = const CompileTimeErrorCode(

[Paul Berry, 2016/04/28 20:12:33]

Should this really be an error?  It's harmless, and I could see it arising as
part of a normal iterative development process.

[Jennifer Messerly, 2016/04/28 20:18:23]

Yeah, that's a good question. I'm fine taking it out. It just seemed odd we were
asked to compile a file and decided to silently ignore it. :)

Changed to be a Warning. Happy to downgrade to a hint too.

+    'UNUSED_PART', 'The part was not used by any libraries being compiled.');