dart2js: rename and refactor reflection_data_parser.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 255 matching lines @@
 
   @override
   jsAst.PropertyAccess typeAccess(Element element) {
     return globalPropertyAccess(element);
   }
 
   List<jsAst.Statement> buildTrivialNsmHandlers(){
     return nsmEmitter.buildTrivialNsmHandlers();
   }
 
-  jsAst.FunctionDeclaration get generateAccessorFunction {
-    const RANGE1_SIZE = RANGE1_LAST - RANGE1_FIRST + 1;
-    const RANGE2_SIZE = RANGE2_LAST - RANGE2_FIRST + 1;
-    const RANGE1_ADJUST = - (FIRST_FIELD_CODE - RANGE1_FIRST);
-    const RANGE2_ADJUST = - (FIRST_FIELD_CODE + RANGE1_SIZE - RANGE2_FIRST);
-    const RANGE3_ADJUST =
-        - (FIRST_FIELD_CODE + RANGE1_SIZE + RANGE2_SIZE - RANGE3_FIRST);
-
-    String receiverParamName = compiler.enableMinification ? "r" : "receiver";
-    String valueParamName = compiler.enableMinification ? "v" : "value";
-    String reflectableField = namer.reflectableField;
-
-    return js.statement('''
-      function generateAccessor(fieldDescriptor, accessors, cls) {
-        var fieldInformation = fieldDescriptor.split("-");
-        var field = fieldInformation[0];
-        var len = field.length;
-        var code = field.charCodeAt(len - 1);
-        var reflectable;
-        if (fieldInformation.length > 1) reflectable = true;
-             else reflectable = false;
-        code = ((code >= $RANGE1_FIRST) && (code <= $RANGE1_LAST))
-              ? code - $RANGE1_ADJUST
-              : ((code >= $RANGE2_FIRST) && (code <= $RANGE2_LAST))
-                ? code - $RANGE2_ADJUST
-                : ((code >= $RANGE3_FIRST) && (code <= $RANGE3_LAST))
-                  ? code - $RANGE3_ADJUST
-                  : $NO_FIELD_CODE;
-
-        if (code) {  // needsAccessor
-          var getterCode = code & 3;
-          var setterCode = code >> 2;
-          var accessorName = field = field.substring(0, len - 1);
-
-          var divider = field.indexOf(":");
-          if (divider > 0) { // Colon never in first position.
-            accessorName = field.substring(0, divider);
-            field = field.substring(divider + 1);
-          }
-
-          if (getterCode) {  // needsGetter
-            var args = (getterCode & 2) ? "$receiverParamName" : "";
-            var receiver = (getterCode & 1) ? "this" : "$receiverParamName";
-            var body = "return " + receiver + "." + field;
-            var property =
-                cls + ".prototype.${namer.getterPrefix}" + accessorName + "=";
-            var fn = "function(" + args + "){" + body + "}";
-            if (reflectable)
-              accessors.push(property + "\$reflectable(" + fn + ");\\n");
-            else
-              accessors.push(property + fn + ";\\n");
-          }
-
-          if (setterCode) {  // needsSetter
-            var args = (setterCode & 2)
-                ? "$receiverParamName,${_}$valueParamName"
-                : "$valueParamName";
-            var receiver = (setterCode & 1) ? "this" : "$receiverParamName";
-            var body = receiver + "." + field + "$_=$_$valueParamName";
-            var property =
-                cls + ".prototype.${namer.setterPrefix}" + accessorName + "=";
-            var fn = "function(" + args + "){" + body + "}";
-            if (reflectable)
-              accessors.push(property + "\$reflectable(" + fn + ");\\n");
-            else
-              accessors.push(property + fn + ";\\n");
-          }
-        }
-
-        return field;
-      }''');
+  jsAst.Statement buildNativeInfoHandler(
+      jsAst.Expression infoAccess,
+      jsAst.Expression constructorAccess,
+      jsAst.Expression subclassReadGenerator(jsAst.Expression subclass),
+      jsAst.Expression interceptorsByTagAccess,
+      jsAst.Expression leafTagsAccess) {
+    return nativeEmitter.buildNativeInfoHandler(infoAccess, constructorAccess,
+                                                subclassReadGenerator,
+                                                interceptorsByTagAccess,
+                                                leafTagsAccess);
   }
 
-  List<jsAst.Node> get defineClassFunction {
-    // First the class name, then the field names in an array and the members
-    // (inside an Object literal).
-    // The caller can also pass in the constructor as a function if needed.
-    //
-    // Example:
-    // defineClass("A", ["x", "y"], {
-    //  foo$1: function(y) {
-    //   print(this.x + y);
-    //  },
-    //  bar$2: function(t, v) {
-    //   this.x = t - v;
-    //  },
-    // });
-
-    bool hasIsolateSupport = compiler.hasIsolateSupport;
-    String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
-
-    jsAst.Expression defineClass = js(r'''
-        function(name, fields) {
-          var accessors = [];
-
-          var str = "function " + name + "(";
-          var body = "";
-          if (#hasIsolateSupport) { var fieldNames = ""; }
-
-          for (var i = 0; i < fields.length; i++) {
-            if(i != 0) str += ", ";
-
-            var field = generateAccessor(fields[i], accessors, name);
-            if (#hasIsolateSupport) { fieldNames += "'" + field + "',"; }
-            var parameter = "p_" + field;
-            str += parameter;
-            body += ("this." + field + " = " + parameter + ";\n");
-          }
-          if (supportsDirectProtoAccess) {
-            body += "this." + #deferredAction + "();";
-          } 
-          str += ") {\n" + body + "}\n";
-          str += name + ".builtin$cls=\"" + name + "\";\n";
-          str += "$desc=$collectedClasses." + name + "[1];\n";
-          str += name + ".prototype = $desc;\n";
-          if (typeof defineClass.name != "string") {
-            str += name + ".name=\"" + name + "\";\n";
-          }
-          if (#hasIsolateSupport) {
-            str += name + "." + #fieldNamesProperty + "=[" + fieldNames
-                   + "];\n";
-          }
-          str += accessors.join("");
-
-          return str;
-        }''', { 'deferredAction': js.string(namer.deferredAction),
-                'hasIsolateSupport': hasIsolateSupport,
-                'fieldNamesProperty': js.string(fieldNamesProperty)});
-
-    // Declare a function called "generateAccessor".  This is used in
-    // defineClassFunction.
-    List result = <jsAst.Node>[
-        generateAccessorFunction,
-        new jsAst.FunctionDeclaration(
-            new jsAst.VariableDeclaration('defineClass'), defineClass) ];
-
-    if (compiler.hasIncrementalSupport) {
-      result.add(
-          js(r'#.defineClass = defineClass', [namer.accessIncrementalHelper]));
-    }
-
-    if (hasIsolateSupport) {
-      jsAst.Expression createNewIsolateFunctionAccess =
-          generateEmbeddedGlobalAccess(embeddedNames.CREATE_NEW_ISOLATE);
-      var createIsolateAssignment =
-          js('# = function() { return new ${namer.isolateName}(); }',
-             createNewIsolateFunctionAccess);
-
-      jsAst.Expression classIdExtractorAccess =
-          generateEmbeddedGlobalAccess(embeddedNames.CLASS_ID_EXTRACTOR);
-      var classIdExtractorAssignment =
-          js('# = function(o) { return o.constructor.name; }',
-              classIdExtractorAccess);
-
-      jsAst.Expression classFieldsExtractorAccess =
-          generateEmbeddedGlobalAccess(embeddedNames.CLASS_FIELDS_EXTRACTOR);
-      var classFieldsExtractorAssignment = js('''
-      # = function(o) {
-        var fieldNames = o.constructor.$fieldNamesProperty;
-        if (!fieldNames) return [];  // TODO(floitsch): do something else here.
-        var result = [];
-        result.length = fieldNames.length;
-        for (var i = 0; i < fieldNames.length; i++) {
-          result[i] = o[fieldNames[i]];
-        }
-        return result;
-      }''', classFieldsExtractorAccess);
-
-      jsAst.Expression instanceFromClassIdAccess =
-          generateEmbeddedGlobalAccess(embeddedNames.INSTANCE_FROM_CLASS_ID);
-      jsAst.Expression allClassesAccess =
-          generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
-      var instanceFromClassIdAssignment =
-          js('# = function(name) { return new #[name](); }',
-             [instanceFromClassIdAccess, allClassesAccess]);
-
-      jsAst.Expression initializeEmptyInstanceAccess =
-          generateEmbeddedGlobalAccess(embeddedNames.INITIALIZE_EMPTY_INSTANCE);
-      var initializeEmptyInstanceAssignment = js('''
-      # = function(name, o, fields) {
-        #[name].apply(o, fields);
-        return o;
-      }''', [ initializeEmptyInstanceAccess, allClassesAccess ]);
-
-      result.addAll([createIsolateAssignment,
-                     classIdExtractorAssignment,
-                     classFieldsExtractorAssignment,
-                     instanceFromClassIdAssignment,
-                     initializeEmptyInstanceAssignment]);
-    }
-
-    return result;
-  }
-
-  /** Needs defineClass to be defined. */
-  jsAst.Expression buildInheritFrom() {
-    jsAst.Expression result = js(r"""
-    // If the browser supports changing the prototype via __proto__, we make
-    // use of that feature. Otherwise, we copy the properties into a new
-    // constructor.
-     supportsDirectProtoAccess ?
-        function(constructor, superConstructor) {
-          var prototype = constructor.prototype;
-          prototype.__proto__ = superConstructor.prototype;
-          // Use a function for `true` here, as functions are stored in the
-          // hidden class and not as properties in the object.
-          prototype.constructor = constructor;
-          prototype[#operatorIsPrefix + constructor.name] = constructor;
-          return convertToFastObject(prototype);
-        } :
-        function() {
-          function tmp() {}
-          return function (constructor, superConstructor) {
-            tmp.prototype = superConstructor.prototype;
-            var object = new tmp();
-            convertToSlowObject(object);
-            var properties = constructor.prototype;
-            var members = Object.keys(properties);
-            for (var i = 0; i < members.length; i++) {
-              var member = members[i];
-              object[member] = properties[member];
-            }
-            // Use a function for `true` here, as functions are stored in the
-            // hidden class and not as properties in the object.
-            object[#operatorIsPrefix + constructor.name] = constructor;
-            object.constructor = constructor;
-            constructor.prototype = object;
-            return object;
-          };
-        }()
-      """, { 'operatorIsPrefix' : js.string(namer.operatorIsPrefix)});
-    if (compiler.hasIncrementalSupport) {
-      result = js(
-          r'#.inheritFrom = #', [namer.accessIncrementalHelper, result]);
-    }
-    return js(r'var inheritFrom = #', [result]);
-  }
-
-  jsAst.Statement buildFinishClass(bool needsNativeSupport) {
-    String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
-
-    jsAst.Expression finishedClassesAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
-
-    jsAst.Expression nativeInfoAccess = js('prototype[$specProperty]', []);
-    jsAst.Expression constructorAccess = js('constructor', []);
-    Function subclassReadGenerator =
-        (jsAst.Expression subclass) => js('allClasses[#]', subclass);
-    jsAst.Expression interceptorsByTagAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
-    jsAst.Expression leafTagsAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
-    jsAst.Statement nativeInfoHandler = nativeEmitter.buildNativeInfoHandler(
-        nativeInfoAccess,
-        constructorAccess,
-        subclassReadGenerator,
-        interceptorsByTagAccess,
-        leafTagsAccess);
-
-    return js.statement('''
-    {
-      var finishedClasses = #finishedClassesAccess;
-
-      function finishClass(cls) {
-
-        if (finishedClasses[cls]) return;
-        finishedClasses[cls] = true;
-
-        var superclass = processedClasses.pending[cls];
-
-        if (#needsMixinSupport) {
-          if (superclass && superclass.indexOf("+") > 0) {
-            var s = superclass.split("+");
-            superclass = s[0];
-            var mixinClass = s[1];
-            finishClass(mixinClass);
-            var mixin = allClasses[mixinClass];
-            var mixinPrototype = mixin.prototype;
-            var clsPrototype = allClasses[cls].prototype;
-
-            var properties = Object.keys(mixinPrototype);
-            for (var i = 0; i < properties.length; i++) {
-              var d = properties[i];
-              if (!hasOwnProperty.call(clsPrototype, d))
-                clsPrototype[d] = mixinPrototype[d];
-            }
-          }
-        }
-
-        // The superclass is only false (empty string) for the Dart Object
-        // class.  The minifier together with noSuchMethod can put methods on
-        // the Object.prototype object, and they show through here, so we check
-        // that we have a string.
-        if (!superclass || typeof superclass != "string") {
-          // Inlined special case of InheritFrom here for performance reasons.
-          // Fix up the the Dart Object class' prototype.
-          var constructor = allClasses[cls];
-          var prototype = constructor.prototype;
-          prototype.constructor = constructor;
-          prototype.#isObject = constructor;
-          prototype.#deferredAction = #markerFun;
-          return;
-        }
-        finishClass(superclass);
-        var superConstructor = allClasses[superclass];
-
-        if (!superConstructor) {
-          superConstructor = existingIsolateProperties[superclass];
-        }
-
-        var constructor = allClasses[cls];
-        var prototype = inheritFrom(constructor, superConstructor);
-
-        if (#needsNativeSupport) {
-          if (Object.prototype.hasOwnProperty.call(prototype, $specProperty)) {
-            #nativeInfoHandler;
-            // As native classes can come into existence without a constructor
-            // call, we have to ensure that the class has been fully
-            // initialized. 
-            if (constructor.prototype.#deferredAction) 
-              finishAddStubsHelper(constructor.prototype);
-          }
-        }
-        // Interceptors (or rather their prototypes) are also used without
-        // first instantiating them first.
-        if (prototype.#isInterceptorClass && 
-            constructor.prototype.#deferredAction) {
-          finishAddStubsHelper(constructor.prototype);
-        }
-      }
-    }''', {'deferredAction': namer.deferredAction,
-           'finishedClassesAccess': finishedClassesAccess,
-           'markerFun': markerFun,
-           'needsMixinSupport': needsMixinSupport,
-           'needsNativeSupport': needsNativeSupport,
-           'nativeInfoHandler': nativeInfoHandler,
-           'isInterceptorClass': namer.operatorIs(backend.jsInterceptorClass),
-           'isObject' : namer.operatorIs(compiler.objectClass) });
+  jsAst.ObjectInitializer generateInterceptedNamesSet() {
+    return interceptorEmitter.generateInterceptedNamesSet();
   }
 
   void emitFinishIsolateConstructorInvocation(CodeOutput output) {
     String isolate = namer.isolateName;
     output.add("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
     if (!element.isClass) return false;
@@ skipping 869 matching lines @@
         mainOutput.add('${globalsHolder}.$globalObject$_=${_}');
       }
       mainOutput.add('map()$N');
     }
 
     mainOutput.add('function ${namer.isolateName}()$_{}\n');
     if (isProgramSplit) {
       mainOutput.add(
           '${globalsHolder}.${namer.isolateName}$_=$_${namer.isolateName}$N'
           '${globalsHolder}.$initName$_=${_}$initName$N'
-          '${globalsHolder}.$parseReflectionDataName$_=$_'
-            '$parseReflectionDataName$N');
+          '${globalsHolder}.$setupProgramName$_=$_'
+            '$setupProgramName$N');
     }
     mainOutput.add('init()$N$n');
     mainOutput.add('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitFunctionThatReturnsNull(mainOutput);
     mainFragment.libraries.forEach(emitLibrary);
 
     Iterable<LibraryElement> libraries =
         task.outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = [];
@@ skipping 21 matching lines @@
         if (element is LibraryElement) {
           writeLibraryDescriptor(libraryBuffer, element);
           elementDescriptors.remove(element);
         }
       }
     }
 
     bool needsNativeSupport = program.needsNativeSupport;
     mainOutput.addBuffer(
         jsAst.prettyPrint(
-            getReflectionDataParser(this, backend, needsNativeSupport),
+            buildSetupProgram(program, compiler, backend, namer, this),
             compiler));
 
     // The argument to reflectionDataParser is assigned to a temporary 'dart'
     // so that 'dart.' will appear as the prefix to dart methods in stack
     // traces and profile entries.
     mainOutput..add('var dart = [$n')
               ..addBuffer(libraryBuffer)
               ..add(']$N');
     if (compiler.useContentSecurityPolicy) {
       jsAst.Statement precompiledFunctionAst =
           buildCspPrecompiledFunctionFor(mainOutputUnit);
       mainOutput.addBuffer(
           jsAst.prettyPrint(
               precompiledFunctionAst,
               compiler,
               monitor: compiler.dumpInfoTask,
               allowVariableMinification: false));
       mainOutput.add(N);
     }
 
-    mainOutput.add('$parseReflectionDataName(dart)$N');
+    mainOutput.add('$setupProgramName(dart)$N');
 
     interceptorEmitter.emitGetInterceptorMethods(mainOutput);
     interceptorEmitter.emitOneShotInterceptors(mainOutput);
 
     if (task.outputContainsConstantList) {
       emitMakeConstantList(mainOutput);
     }
 
     // Constants in checked mode call into RTI code to set type information
     // which may need getInterceptor (and one-shot interceptor) methods, so
@@ skipping 411 matching lines @@
           ..add(buildGeneratedBy())
           ..add('${deferredInitializers}.current$_=$_'
                    'function$_(${globalsHolder}) {$N');
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         output
             .add('var $globalObject$_=$_'
                      '${globalsHolder}.$globalObject$N');
       }
       output
           ..add('var init$_=$_${globalsHolder}.init$N')
-          ..add('var $parseReflectionDataName$_=$_'
-                    '$globalsHolder.$parseReflectionDataName$N')
+          ..add('var $setupProgramName$_=$_'
+                    '$globalsHolder.$setupProgramName$N')
           ..add('var ${namer.isolateName}$_=$_'
                     '${globalsHolder}.${namer.isolateName}$N');
       if (libraryDescriptorBuffer != null) {
         // TODO(ahe): This defines a lot of properties on the
         // Isolate.prototype object.  We know this will turn it into a
         // slow object in V8, so instead we should do something similar
         // to Isolate.$finishIsolateConstructor.
         output
             ..add('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
             // The argument to reflectionDataParser is assigned to a temporary
             // 'dart' so that 'dart.' will appear as the prefix to dart methods
             // in stack traces and profile entries.
             ..add('var dart = [$n ')
             ..addBuffer(libraryDescriptorBuffer)
             ..add(']$N');
 
         if (compiler.useContentSecurityPolicy) {
           jsAst.Statement precompiledFunctionAst =
               buildCspPrecompiledFunctionFor(outputUnit);
 
           output.addBuffer(
               jsAst.prettyPrint(
                   precompiledFunctionAst, compiler,
                   monitor: compiler.dumpInfoTask,
                   allowVariableMinification: false));
           output.add(N);
         }
-        output.add('$parseReflectionDataName(dart)$N');
+        output.add('$setupProgramName(dart)$N');
       }
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
       // After we have done the setup it must point to the current Isolate.
       // Otherwise all methods/functions accessing isolate variables will
@@ skipping 89 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }