dart2js: patch file support cleanup

pkg/compiler/lib/src/patch_parser.dart

 // Copyright (c) 2012, 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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 209 matching lines @@
 
   PatchMemberListener(Compiler compiler, ClassElement enclosingClass)
       : this.compiler = compiler,
         super(compiler.parsingContext.getScannerOptionsFor(enclosingClass),
             compiler.reporter, enclosingClass);
 
   @override
   void addMember(Element patch) {
     addMetadata(patch);
 
-    PatchVersion patchVersion = getPatchVersion(compiler, patch);
-    if (patchVersion != null) {
-      if (patchVersion.isActive(compiler.patchVersion)) {
-        Element origin = enclosingClass.origin.localLookup(patch.name);
-        patchElement(compiler, reporter, origin, patch);
-        enclosingClass.addMember(patch, reporter);
-      } else {
-        // Skip this element.
-      }
+    if (_isMarkedAsPatch(compiler, patch)) {
+      Element origin = enclosingClass.origin.localLookup(patch.name);
+      patchElement(compiler, reporter, origin, patch);
+      enclosingClass.addMember(patch, reporter);
     } else {
       if (Name.isPublicName(patch.name)) {
         reporter.reportErrorMessage(patch, MessageKind.INJECTED_PUBLIC_MEMBER);
       }
       enclosingClass.addMember(patch, reporter);
     }
   }
 }
 
 /**
  * Extension of [ElementListener] for parsing patch files.
  */
 class PatchElementListener extends ElementListener implements Listener {
   final Compiler compiler;
 
   PatchElementListener(Compiler compiler, CompilationUnitElement patchElement,
       IdGenerator idGenerator)
       : this.compiler = compiler,
         super(compiler.parsingContext.getScannerOptionsFor(patchElement),
             compiler.reporter, patchElement, idGenerator);
 
   @override
   void pushElement(Element patch) {
     popMetadata(patch);
 
-    PatchVersion patchVersion = getPatchVersion(compiler, patch);
-    if (patchVersion != null) {
-      if (patchVersion.isActive(compiler.patchVersion)) {
-        LibraryElement originLibrary = compilationUnitElement.library;
-        assert(originLibrary.isPatched);
-        Element origin = originLibrary.localLookup(patch.name);
-        patchElement(compiler, reporter, origin, patch);
-        compilationUnitElement.addMember(patch, reporter);
-      } else {
-        // Skip this element.
-      }
+    if (_isMarkedAsPatch(compiler, patch)) {
+      LibraryElement originLibrary = compilationUnitElement.library;
+      assert(originLibrary.isPatched);
+      Element origin = originLibrary.localLookup(patch.name);
+      patchElement(compiler, reporter, origin, patch);
+      compilationUnitElement.addMember(patch, reporter);
     } else {
       if (Name.isPublicName(patch.name)) {
         reporter.reportErrorMessage(patch, MessageKind.INJECTED_PUBLIC_MEMBER);
       }
       compilationUnitElement.addMember(patch, reporter);
     }
   }
 }
 
 void patchElement(Compiler compiler, DiagnosticReporter reporter,
@@ skipping 89 matching lines @@
       }
     }
     return handler.defaultResult;
   }
 
   /// Result that signals the absence of annotations.
   T get defaultResult => null;
 }
 
 /// Annotation handler for pre-resolution detection of `@patch` annotations.
-class PatchAnnotationHandler extends EagerAnnotationHandler<PatchVersion> {
+class PatchAnnotationHandler extends EagerAnnotationHandler<bool> {
   const PatchAnnotationHandler();
 
-  PatchVersion getPatchVersion(MetadataAnnotationX annotation) {
-    if (annotation.beginToken != null) {
-      if (annotation.beginToken.next.lexeme == 'patch') {
-        return const PatchVersion(null);
-      } else if (annotation.beginToken.next.lexeme == 'patch_full') {
-        return const PatchVersion('full');
-      } else if (annotation.beginToken.next.lexeme == 'patch_lazy') {
-        return const PatchVersion('lazy');
-      } else if (annotation.beginToken.next.lexeme == 'patch_startup') {
-        return const PatchVersion('startup');
-      }
+  @override
+  bool apply(
+      Compiler compiler, Element element, MetadataAnnotation annotation) {
+    MetadataAnnotationX meta = annotation;
+    if (meta.beginToken?.next?.lexeme == 'patch') {
+      return true;
     }
     return null;
   }
 
   @override
-  PatchVersion apply(
-      Compiler compiler, Element element, MetadataAnnotation annotation) {
-    return getPatchVersion(annotation);
-  }
-
-  @override
   void validate(Compiler compiler, Element element,
       MetadataAnnotation annotation, ConstantValue constant) {
     ResolutionDartType annotationType =
         constant.getType(compiler.commonElements);
     if (annotationType.element !=
         compiler.commonElements.patchAnnotationClass) {
       DiagnosticReporter reporter = compiler.reporter;
       reporter.internalError(annotation, 'Invalid patch annotation.');
     }
   }
@@ skipping 94 matching lines @@
         ]);
     return;
   }
   if (origin.isPatched) {
     reporter.internalError(
         origin, "Trying to patch a function more than once.");
   }
   origin.applyPatch(patch);
 }
 
-PatchVersion getPatchVersion(Compiler compiler, Element element) {
+bool _isMarkedAsPatch(Compiler compiler, Element element) {
   return EagerAnnotationHandler.checkAnnotation(
-      compiler, element, const PatchAnnotationHandler());
+          compiler, element, const PatchAnnotationHandler()) ==
+      true;
 }
-
-class PatchVersion {
-  final String tag;
-
-  const PatchVersion(this.tag);
-
-  bool isActive(String patchTag) => tag == null || tag == patchTag;
-
-  String toString() => 'PatchVersion($tag)';
-}