Supported versioned patching.

pkg/compiler/lib/src/compiler.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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 233 matching lines @@
   /// constants.
   BackendConstantEnvironment get constants;
 
   /// The compiler task responsible for the compilation of constants for both
   /// the frontend and the backend.
   ConstantCompilerTask get constantCompilerTask;
 
   /// Backend callback methods for the resolution phase.
   ResolutionCallbacks get resolutionCallbacks;
 
+  // TODO(johnniwinther): Move this to the JavaScriptBackend.
+  String get patchVersion => null;
+
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> classesRequiredForReflection = const [];
 
   // Given a [FunctionElement], return a buffer with the code generated for it
   // or null if no code was generated.
   CodeBuffer codeOf(Element element) => null;
 
   void initializeHelperClasses() {}
 
@@ skipping 529 matching lines @@
   ClassElement get streamClass => _coreTypes.streamClass;
 
   CoreTypes get coreTypes => _coreTypes;
 
   ClassElement typedDataClass;
 
   /// The constant for the [proxy] variable defined in dart:core.
   ConstantValue proxyConstant;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
-  /// The constant for the [patch] variable defined in dart:_js_helper.
-  ConstantValue patchConstant;
+  /// The class for patch annotation defined in dart:_js_helper.
+  ClassElement patchAnnotationClass;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
   ClassElement nativeAnnotationClass;
 
   // Initialized after symbolClass has been resolved.
   FunctionElement symbolConstructor;
 
   // Initialized when dart:mirrors is loaded.
   ClassElement mirrorSystemClass;
 
@@ skipping 423 matching lines @@
     } else if (uri == DART_MIRRORS) {
       mirrorSystemClass = findRequiredElement(library, 'MirrorSystem');
       mirrorsUsedClass = findRequiredElement(library, 'MirrorsUsed');
     } else if (uri == DART_ASYNC) {
       deferredLibraryClass = findRequiredElement(library, 'DeferredLibrary');
       _coreTypes.futureClass = findRequiredElement(library, 'Future');
       _coreTypes.streamClass = findRequiredElement(library, 'Stream');
     } else if (uri == DART_NATIVE_TYPED_DATA) {
       typedDataClass = findRequiredElement(library, 'NativeTypedData');
     } else if (uri == js_backend.JavaScriptBackend.DART_JS_HELPER) {
+      patchAnnotationClass = findRequiredElement(library, '_Patch');
       nativeAnnotationClass = findRequiredElement(library, 'Native');
     }
     return backend.onLibraryScanned(library, loader);
   }
 
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
   /// have been computed.
   ///
   /// [loadedLibraries] contains the newly loaded libraries.
@@ skipping 62 matching lines @@
                  MessageKind.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
       }
 
       functionClass.ensureResolved(this);
       functionApplyMethod = functionClass.lookupLocalMember('apply');
 
       proxyConstant =
           resolver.constantCompiler.compileConstant(
               coreLibrary.find('proxy')).value;
 
-      // TODO(johnniwinther): Move this to the JavaScript backend.
-      LibraryElement jsHelperLibrary = loadedLibraries.getLibrary(
-              js_backend.JavaScriptBackend.DART_JS_HELPER);
-      if (jsHelperLibrary != null) {
-        patchConstant = resolver.constantCompiler.compileConstant(
-            jsHelperLibrary.find('patch')).value;
-      }
-
       if (preserveComments) {
         return libraryLoader.loadLibrary(DART_MIRRORS)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
   Element findRequiredElement(LibraryElement library, String name) {
     var element = library.find(name);
     if (element == null) {
       internalError(library,
           "The library '${library.canonicalUri}' does not contain required "
           "element: '$name'.");
       }
     return element;
   }
 
+  // TODO(johnniwinther): Move this to [PatchParser] when it is moved to the
+  // [JavaScriptBackend]. Currently needed for testing.
+  String get patchVersion => backend.patchVersion;
+
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
       mirrorSystemGetNameFunction =
         cls.lookupLocalMember('getName');
     } else if (symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
     } else if (symbolImplementationClass == cls) {
       symbolValidatedConstructor = symbolImplementationClass.lookupConstructor(
           symbolValidatedConstructorSelector);
     } else if (mirrorsUsedClass == cls) {
@@ skipping 1029 matching lines @@
   InterfaceType get nullType => nullClass.computeType(compiler);
 
   @override
   InterfaceType get numType => numClass.computeType(compiler);
 
   @override
   InterfaceType get stringType =>  stringClass.computeType(compiler);
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);