Checks for entry point existence and supports warning suppression.

reflectable/lib/src/transformer_implementation.dart

 // (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 library reflectable.src.transformer_implementation;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:developer' as developer;
 import 'dart:io';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/resolver.dart';
 import 'package:dart_style/dart_style.dart';
 import 'package:path/path.dart' as path;
 import 'element_capability.dart' as ec;
 import 'encoding_constants.dart' as constants;
 import 'fixed_point.dart';
 import 'reflectable_class_constants.dart' as reflectable_class_constants;
 import 'transformer_errors.dart' as errors;
 
+/// Specifiers for warnings that may be suppressed; `allWarnings` disables all
+/// warnings, and the remaining values are concerned with individual warnings.
+/// Remember to update the explanatory text in [_findSuppressWarnings] whenever
+/// this list is updated.
+enum WarningKind {
+  missingEntryPoint,
+  badSuperclass,
+  badNamePattern,
+  badMetadata
+}
+
 // Single source of instances of [Resolver], shared across multiple
 // invocations of `apply` to save memory.
 Resolvers _resolvers = new Resolvers(dartSdkDirectory);
 
 class ReflectionWorld {
   final Resolver resolver;
   final AssetId generatedLibraryId;
   final List<_ReflectorDomain> reflectors;
   final LibraryElement reflectableLibrary;
   final LibraryElement entryPointLibrary;
@@ skipping 2215 matching lines @@
 // because we will then simply work on a normal Dart program that uses
 // dart:mirrors, which should have the same behavior as the translated
 // program, and this could work quite well in practice, except for
 // debugging which is concerned with the generated code (but that would
 // ideally be an infrequent occurrence).
 
 class TransformerImplementation {
   TransformLogger _logger;
   Resolver _resolver;
   bool _formatted;
+  List<WarningKind> _suppressedWarnings;
+
+  bool _warningEnabled(WarningKind kind) {
+    return !_suppressedWarnings.contains(kind);
+  }
 
   /// Checks whether the given [type] from the target program is "our"
   /// class [Reflectable] by looking up the static field
   /// [Reflectable.thisClassId] and checking its value (which is a 40
   /// character string computed by sha1sum on an old version of
   /// reflectable.dart).
   ///
   /// Discussion of approach: Checking that we have found the correct
   /// [Reflectable] class is crucial for correctness, and the "obvious"
   /// approach of just looking up the library and then the class with the
@@ skipping 14 matching lines @@
     if (idField is ConstFieldElementImpl) {
       EvaluationResultImpl idResult = idField.evaluationResult;
       if (idResult != null) {
         return idField.constantValue.toStringValue() ==
             reflectable_class_constants.id;
       }
       // idResult == null: analyzer/.../element.dart does not specify
       // whether this could happen, but it is surely not the right
       // class, so we fall through.
     }
-    // Not a const field, cannot be the right class.
+    // Not a const field, or failed the test, cannot be the right class.
     return false;
   }
 
   /// Returns the ClassElement in the target program which corresponds to class
   /// [Reflectable].
   ClassElement _findReflectableClassElement(LibraryElement reflectableLibrary) {
     for (CompilationUnitElement unit in reflectableLibrary.units) {
       for (ClassElement type in unit.types) {
         if (type.name == reflectable_class_constants.name &&
             _equalsClassReflectable(type)) {
@@ skipping 90 matching lines @@
     // have no effect; it might be better to emit a diagnostic message (a
     // hint?) in order to notify the programmer that "it does not work".
     // The trade-off is that such constructs may have been written by
     // programmers who are doing something else, intentionally.  To emit a
     // diagnostic message, we must check whether there is a Reflectable
     // somewhere inside this syntactic construct, and then emit the message
     // in cases that we "consider likely to be misunderstood".
     return null;
   }
 
-  _warn(String message, Element element) {
-    _logger.warning(message,
-        asset: _resolver.getSourceAssetId(element),
-        span: _resolver.getSourceSpan(element));
+  _warn(WarningKind kind, String message, [Element element]) {
+    if (_warningEnabled(kind)) {
+      if (element != null) {
+        _logger.warning(message,
+            asset: _resolver.getSourceAssetId(element),
+            span: _resolver.getSourceSpan(element));
+      } else {
+        _logger.warning(message);
+      }
+    }
   }
 
   /// Finds all GlobalQuantifyCapability and GlobalQuantifyMetaCapability
   /// annotations on imports of [reflectableLibrary], and record the arguments
   /// of these annotations by modifying [globalPatterns] and [globalMetadata].
   void _findGlobalQuantifyAnnotations(
       Map<RegExp, List<ClassElement>> globalPatterns,
       Map<ClassElement, List<ClassElement>> globalMetadata) {
     LibraryElement reflectableLibrary =
         _resolver.getLibraryByName("reflectable.reflectable");
@@ skipping 15 matching lines @@
       for (ImportElement import in library.imports) {
         for (ElementAnnotationImpl metadatum in import.metadata) {
           if (metadatum.element == globalQuantifyCapabilityConstructor) {
             EvaluationResultImpl evaluation = metadatum.evaluationResult;
             if (evaluation != null && evaluation.value != null) {
               DartObjectImpl value = evaluation.value;
               String pattern = value.fields["classNamePattern"].toStringValue();
               if (pattern == null) {
                 // TODO(sigurdm) implement: Create a span for the annotation
                 // rather than the import.
-                _warn("The classNamePattern must be a string", import);
+                _warn(WarningKind.badNamePattern,
+                    "The classNamePattern must be a string", import);
                 continue;
               }
               ClassElement reflector =
                   value.fields["(super)"].fields["reflector"].type.element;
               if (reflector == null ||
                   reflector.type.element.supertype.element !=
                       reflectableClass) {
                 String found =
                     reflector == null ? "" : " Found ${reflector.name}";
                 _warn(
+                    WarningKind.badSuperclass,
                     "The reflector must be a direct subclass of Reflectable." +
                         found,
                     import);
                 continue;
               }
               globalPatterns
                   .putIfAbsent(new RegExp(pattern), () => <ClassElement>[])
                   .add(reflector);
             }
           } else if (metadatum.element ==
               globalQuantifyMetaCapabilityConstructor) {
             EvaluationResultImpl evaluation = metadatum.evaluationResult;
             if (evaluation?.value != null) {
               DartObjectImpl value = evaluation.value;
               Object metadataFieldValue =
                   value.fields["metadataType"].toTypeValue().element;
               if (metadataFieldValue == null ||
                   value.fields["metadataType"].type.element != typeClass) {
                 // TODO(sigurdm) implement: Create a span for the annotation.
                 _warn(
+                    WarningKind.badMetadata,
                     "The metadata must be a Type. "
                     "Found ${value.fields["metadataType"].type.element.name}",
                     import);
                 continue;
               }
               ClassElement reflector =
                   value.fields["(super)"].fields["reflector"].type.element;
               if (reflector == null ||
                   reflector.type.element.supertype.element !=
                       reflectableClass) {
                 String found =
                     reflector == null ? "" : " Found ${reflector.name}";
                 _warn(
+                    WarningKind.badSuperclass,
                     "The reflector must be a direct subclass of Reflectable." +
                         found,
                     import);
                 continue;
               }
               globalMetadata
                   .putIfAbsent(metadataFieldValue, () => <ClassElement>[])
                   .add(reflector);
             }
           }
         }
       }
     }
   }
 
   /// Returns a [ReflectionWorld] instantiated with all the reflectors seen by
   /// [_resolver] and all classes annotated by them. The [reflectableLibrary]
   /// must be the element representing 'package:reflectable/reflectable.dart',
   /// the [entryPoint] must be the element representing the entry point under
   /// transformation, and [dataId] must represent the entry point as well,
   /// and it is used to decide whether it is possible to import other libraries
   /// from the entry point. If the transformation is guaranteed to have no
   /// effect the return value is [null].
   ReflectionWorld _computeWorld(LibraryElement reflectableLibrary,
       LibraryElement entryPoint, AssetId dataId) {
     final ClassElement classReflectable =
         _findReflectableClassElement(reflectableLibrary);
     // If class `Reflectable` is absent the transformation must be a no-op.
-    if (classReflectable == null) return null;
+    if (classReflectable == null) {
+      _logger.info("Ignoring entry point $entryPoint that does not "
+          "include the class `Reflectable`.");
+      return null;
+    }
 
     // The world will be built from the library arguments plus these two.
     final Map<ClassElement, _ReflectorDomain> domains =
         <ClassElement, _ReflectorDomain>{};
     final _ImportCollector importCollector = new _ImportCollector();
 
     // Maps each pattern to the list of reflectors associated with it via
     // a [GlobalQuantifyCapability].
     Map<RegExp, List<ClassElement>> globalPatterns =
         <RegExp, List<ClassElement>>{};
@@ skipping 206 matching lines @@
     }
 
     /// Extracts the namePattern String from an instance of a subclass of
     /// NamePatternCapability.
     String extractNamePattern(DartObjectImpl constant) {
       if (constant.fields == null ||
           constant.fields["(super)"] == null ||
           constant.fields["(super)"].fields["namePattern"] == null ||
           constant.fields["(super)"].fields["namePattern"].toStringValue() ==
               null) {
-        // TODO(sigurdm) diagnostic: Better error-message.
-        _logger.warning("Could not extract namePattern.");
+        // TODO(eernst) implement: Add location info to message.
+        _warn(WarningKind.badNamePattern,
+            "Could not extract namePattern from capability.");
+        return "";
       }
       return constant.fields["(super)"].fields["namePattern"].toStringValue();
     }
 
     /// Extracts the metadata property from an instance of a subclass of
     /// MetadataCapability.
     ClassElement extractMetaData(DartObjectImpl constant) {
       if (constant.fields == null ||
           constant.fields["(super)"] == null ||
           constant.fields["(super)"].fields["metadataType"] == null) {
-        // TODO(sigurdm) diagnostic: Better error-message. We need a way
-        // to get a source location from a constant.
-        _logger.warning("Could not extract the metadata field.");
+        // TODO(eernst) implement: Add location info to message.
+        _warn(WarningKind.badMetadata,
+            "Could not extract metadata type from capability.");
         return null;
       }
       Object metadataFieldValue = constant.fields["(super)"].fields[
           "metadataType"].toTypeValue().element;
       if (metadataFieldValue is! ClassElement) {
-        _logger.warning("The metadataType field must be a Type object.");
+        // TODO(eernst) implement: Add location info to message.
+        _warn(WarningKind.badMetadata,
+            "Metadata specification in capability must be a `Type`.");
         return null;
       }
       return metadataFieldValue;
     }
 
     switch (classElement.name) {
       case "_NameCapability":
         return ec.nameCapability;
       case "_ClassifyCapability":
         return ec.classifyCapability;
@@ skipping 177 matching lines @@
       DartFormatter formatter = new DartFormatter();
       result = formatter.format(result);
     }
     return result;
   }
 
   /// Performs the transformation which eliminates all imports of
   /// `package:reflectable/reflectable.dart` and instead provides a set of
   /// statically generated mirror classes.
   Future apply(AggregateTransform aggregateTransform, List<String> entryPoints,
-      bool formatted) async {
+      bool formatted, List<WarningKind> suppressedWarnings) async {
     _logger = aggregateTransform.logger;
     _formatted = formatted;
+    _suppressedWarnings = suppressedWarnings;
     // The type argument in the return type is omitted because the
     // documentation on barback and on transformers do not specify it.
 
     List<Asset> assets = await aggregateTransform.primaryInputs.toList();
 
     if (assets.isEmpty) {
       // It is not an error to have nothing to transform.
       _logger.info("Nothing to transform");
       // Terminate with a non-failing status code to the OS.
       exit(0);
     }
 
     // TODO(eernst) algorithm: Build a mapping from entry points to assets by
     // iterating over `assets` and doing a binary search on a sorted
     // list of entry points: if A is the number of assets and E is the
     // number of entry points (note: E < A, and E == 1 could be quite
     // common), this would cost O(A*log(E)), whereas the current
     // approach costs O(A*E). OK, it's log(E)+epsilon, not 0 when E == 1.
     for (String entryPoint in entryPoints) {
       // Find the asset corresponding to [entryPoint]
       Asset entryPointAsset = assets.firstWhere(
           (Asset asset) => asset.id.path.endsWith(entryPoint),
           orElse: () => null);
       if (entryPointAsset == null) {
-        aggregateTransform.logger.info("Missing entry point: $entryPoint");
+        if (_warningEnabled(WarningKind.missingEntryPoint)) {
+          String entryPointPath =
+              entryPoint.split('/').join(Platform.pathSeparator);
+          bool entryPointFileExists = await new File(entryPointPath).exists();

[jakemac, 2015/11/17 14:58:07]

This is definitely an anti-pattern for transformers in general... I guess it
doesn't hurt though as long as you are checking for the entry point in the
provided assets first (it could be generated by a previous phase, and would not
live on disk).

+          if (!entryPointFileExists) {
+            // We did not receive an asset for [entryPoint], and there is no
+            // corresponding file (so it is not just because we were invoked
+            // from `pub build test` and [entryPoint] is in `web`, or something
+            // similar). Announce the problem.
+            aggregateTransform.logger
+                .warning("Missing entry point: $entryPoint");
+          }
+        }
         continue;
       }
       Transform wrappedTransform =
           new _AggregateTransformWrapper(aggregateTransform, entryPointAsset);
 
       _resolver = await _resolvers.get(wrappedTransform);
       LibraryElement reflectableLibrary =
           _resolver.getLibraryByName("reflectable.reflectable");
       if (reflectableLibrary == null) {
         // Stop and do not consumePrimary, i.e., let the original source
@@ skipping 1059 matching lines @@
   return functionElement == null
       ? "null"
       : "${functionElement.library.name}.${functionElement.name}";
 }
 
 String _qualifiedTypeParameterName(TypeParameterElement typeParameterElement) {
   if (typeParameterElement == null) return "null";
   return "${_qualifiedName(typeParameterElement.enclosingElement)}."
       "${typeParameterElement.name}";
 }