Minifying renamer for classes, methods and instance variables.

lib/compiler/implementation/js_backend/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 73 matching lines @@
       => '${namer.ISOLATE}.\$finishIsolateConstructor';
   String get pendingClassesName
       => '${namer.ISOLATE}.\$pendingClasses';
   String get isolatePropertiesName
       => '${namer.ISOLATE}.${namer.ISOLATE_PROPERTIES}';
   String get supportsProtoName
       => 'supportsProto';
   String get lazyInitializerName
       => '${namer.ISOLATE}.\$lazy';
 
-  final String GETTER_SUFFIX = "?";
-  final String SETTER_SUFFIX = "!";
-  final String GETTER_SETTER_SUFFIX = "=";
+  // Property name suffixes.  If the accessors are renaming then the format
+  // is <accessorName>:<fieldName><suffix>.  We use the suffix to know whether
+  // to look for the ':' separator in order to avoid doing the indexOf operation
+  // on every single property (they are quite rare).  None of these characters
+  // are legal in an identifier and they are related by bit patterns.
+  // setter          <          0x3c
+  // both            =          0x3d
+  // getter          >          0x3e
+  // renaming setter |          0x7c
+  // renaming both   }          0x7d
+  // renaming getter ~          0x7e
+  const SUFFIX_MASK = 0x3f;
+  const FIRST_SUFFIX_CODE = 0x3c;
+  const SETTER_CODE = 0x3c;
+  const GETTER_SETTER_CODE = 0x3d;
+  const GETTER_CODE = 0x3e;
+  const RENAMING_FLAG = 0x40;
+  String needsGetter(String variable) => '($variable & 3) > 0';

[floitsch, 2012/10/25 12:58:38]

needsGetterCode or something to indicate that this is just the code to do this
check dynamically.
other possibility: needsGetterExpression

[erikcorry, 2012/12/06 09:38:07]

Done.

+  String needsSetter(String variable) => '($variable & 2) == 0';
+  String isRenaming(String variable) => '($variable & $RENAMING_FLAG) != 0';
 
   String get generateGetterSetterFunction {
     return """
   function(field, prototype) {
     var len = field.length;
-    var lastChar = field[len - 1];
-    var needsGetter = lastChar == '$GETTER_SUFFIX' || lastChar == '$GETTER_SETTER_SUFFIX';
-    var needsSetter = lastChar == '$SETTER_SUFFIX' || lastChar == '$GETTER_SETTER_SUFFIX';
-    if (needsGetter || needsSetter) field = field.substring(0, len - 1);
-    if (needsGetter) {
-      var getterString = "return this." + field + ";";
-  """
-  /* The supportsProtoCheck below depends on the getter/setter convention.
-         When changing here, update the protoCheck too. */
-  """
-      prototype["get\$" + field] = new Function(getterString);
-    }
-    if (needsSetter) {
-      var setterString = "this." + field + " = v;";
-      prototype["set\$" + field] = new Function("v", setterString);
+    var lastCharCode = field.charCodeAt(len - 1);
+    var needsAccessor = (lastCharCode & $SUFFIX_MASK) >= $FIRST_SUFFIX_CODE;
+    if (needsAccessor) {
+      var needsGetter = ${needsGetter('lastCharCode')};
+      var needsSetter = ${needsSetter('lastCharCode')};
+      var renaming = ${isRenaming('lastCharCode')};
+      var accessorName = field = field.substring(0, len - 1);

[floitsch, 2012/10/25 08:42:40]

remove "field =".

[erikcorry, 2012/10/25 09:09:28]

Then it won't work any more!?

[floitsch, 2012/10/25 12:58:38]

never mind. wasn't thinking.
Please put in two lines, though.

+      if (renaming) {
+        var divider = field.indexOf(":");
+        accessorName = field.substring(0, divider);
+        field = field.substring(divider + 1);
+      }
+      if (needsGetter) {
+        var getterString = "return this." + field + ";";
+        prototype["get\$" + accessorName] = new Function(getterString);
+      }
+      if (needsSetter) {
+        var setterString = "this." + field + " = v;";
+        prototype["set\$" + accessorName] = new Function("v", setterString);
+      }
     }
     return field;
   }""";
   }
 
   String get defineClassFunction {
     // First the class name, then the super class name, followed by the fields
     // (in an array) and the members (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
@@ skipping 349 matching lines @@
     //
     // We need to generate a stub for (5) because the order of the
     // stub arguments and the real method may be different.
 
     // Keep a cache of which stubs have already been generated, to
     // avoid duplicates. Note that even if selectors are
     // canonicalized, we would still need this cache: a typed selector
     // on A and a typed selector on B could yield the same stub.
     Set<String> generatedStubNames = new Set<String>();
     if (compiler.enabledFunctionApply
-        && member.name == Namer.CLOSURE_INVOCATION_NAME) {
+        && member.name == namer.CLOSURE_INVOCATION_NAME) {
       // If [Function.apply] is called, we pessimistically compile all
       // possible stubs for this closure.
       // TODO(5074): This functionality only supports the new
       // parameter specification, and this comment should be removed
       // once the old specification is not supported.
       FunctionSignature signature = member.computeSignature(compiler);
       Set<Selector> selectors = signature.optionalParametersAreNamed
           ? computeNamedSelectors(signature, member)
           : computeOptionalSelectors(signature, member);
       for (Selector selector in selectors) {
@@ skipping 176 matching lines @@
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void visitClassFields(ClassElement classElement,
                         void addField(Element member,
                                       String name,
+                                      String accessorName,
                                       bool needsGetter,
                                       bool needsSetter,
                                       bool needsCheckedSetter)) {
     assert(invariant(classElement, classElement.isDeclaration));
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
         compiler.codegenWorld.instantiatedClasses.contains(classElement);
 
     void visitField(ClassElement enclosingClass, Element member) {
@@ skipping 15 matching lines @@
       if (identical(enclosingClass, classElement)) {
         needsGetter = instanceFieldNeedsGetter(member);
         needsSetter = instanceFieldNeedsSetter(member);
       } else {
         isShadowed = classElement.isShadowedByField(member);
       }
 
       if ((isInstantiated && !enclosingClass.isNative())
           || needsGetter
           || needsSetter) {
-        String fieldName = isShadowed
+        String accessorName = isShadowed
             ? namer.shadowedFieldName(member)
             : namer.getName(member);
+        String fieldName = enclosingClass.isNative() ?
+            member.name.slowToString() : accessorName;
         bool needsCheckedSetter = false;
         if (needsSetter && compiler.enableTypeAssertions
             && canGenerateCheckedSetter(member)) {
           needsCheckedSetter = true;
           needsSetter = false;
         }
         // Getters and setters with suffixes will be generated dynamically.
         addField(member,
                  fieldName,
+                 accessorName,
                  needsGetter,
                  needsSetter,
                  needsCheckedSetter);
       }
     }
 
     // If a class is not instantiated then we add the field just so we can
     // generate the field getter/setter dynamically. Since this is only
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.implementation.forEachInstanceField(
         visitField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
-  void generateGetter(Element member, String fieldName, CodeBuffer buffer) {
-    String getterName = namer.getterName(member.getLibrary(), member.name);
+  void generateGetter(Element member, String fieldName, String accessorName,
+                      CodeBuffer buffer) {
+    String getterName =
+        namer.getterName(member.getLibrary(), new SourceString(accessorName));
     buffer.add("$getterName: function() { return this.$fieldName; }");
   }
 
-  void generateSetter(Element member, String fieldName, CodeBuffer buffer) {
-    String setterName = namer.setterName(member.getLibrary(), member.name);
+  void generateSetter(Element member, String fieldName, String accessorName,
+                      CodeBuffer buffer) {
+    String setterName =
+        namer.setterName(member.getLibrary(), new SourceString(accessorName));
     buffer.add("$setterName: function(v) { this.$fieldName = v; }");
   }
 
   bool canGenerateCheckedSetter(Element member) {
     DartType type = member.computeType(compiler);
     if (type.element.isTypeVariable()
         || type.element == compiler.dynamicClass
         || type.element == compiler.objectClass) {
       // TODO(ngeoffray): Support type checks on type parameters.
       return false;
     }
     return true;
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
+                             String accessorName,
                              CodeBuffer buffer) {
     assert(canGenerateCheckedSetter(member));
     DartType type = member.computeType(compiler);
     SourceString helper = compiler.backend.getCheckedModeHelper(type);
     FunctionElement helperElement = compiler.findHelper(helper);
     String helperName = namer.isolateAccess(helperElement);
     String additionalArgument = '';
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
       additionalArgument = ", '${namer.operatorIs(type.element)}'";
     }
-    String setterName = namer.setterName(member.getLibrary(), member.name);
+    String setterName =
+        namer.setterName(member.getLibrary(), new SourceString(accessorName));
     buffer.add("$setterName: function(v) { "
         "this.$fieldName = $helperName(v$additionalArgument); }");
   }
 
   void emitClassConstructor(ClassElement classElement, CodeBuffer buffer) {
     /* Do nothing. */
   }
 
   void emitClassFields(ClassElement classElement, CodeBuffer buffer) {
     buffer.add('"": [');
     bool isFirstField = true;
     visitClassFields(classElement, (Element member,
                                     String name,
+                                    String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       if (isFirstField) {
         isFirstField = false;
       } else {
         buffer.add(", ");
       }
-      buffer.add('"$name');
+      buffer.add('"$accessorName');
+      int flag = 0;
+      if (name != accessorName) {
+        buffer.add(':$name');
+        assert(needsGetter || needsSetter);
+        flag = RENAMING_FLAG;
+      }
       if (needsGetter && needsSetter) {
-        buffer.add(GETTER_SETTER_SUFFIX);
+        buffer.addCharCode(GETTER_SETTER_CODE + flag);

[floitsch, 2012/10/25 12:58:38]

I would prefer "|" to indicate that this is a bit-operation.

[erikcorry, 2012/12/06 09:38:07]

Done.

       } else if (needsGetter) {
-        buffer.add(GETTER_SUFFIX);
+        buffer.addCharCode(GETTER_CODE + flag);
       } else if (needsSetter) {
-        buffer.add(SETTER_SUFFIX);
+        buffer.addCharCode(SETTER_CODE + flag);
       }
       buffer.add('"');
     });
     buffer.add(']');
   }
 
   /** Each getter/setter must be prefixed with a ",\n ". */
   void emitClassGettersSetters(ClassElement classElement, CodeBuffer buffer,
                                {bool omitLeadingComma: false}) {
     visitClassFields(classElement, (Element member,
                                     String name,
+                                    String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       if (needsCheckedSetter) {
         assert(!needsSetter);
         if (!omitLeadingComma) {
           buffer.add(",\n ");
         } else {
           omitLeadingComma = false;
         }
-        generateCheckedSetter(member, name, buffer);
+        generateCheckedSetter(member, name, accessorName, buffer);
       }
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void generateClass(ClassElement classElement, CodeBuffer buffer) {
@@ skipping 166 matching lines @@
 
   void emitStaticFunctionGetters(CodeBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
+          new ClosureInvocationElement(namer.CLOSURE_INVOCATION_NAME, element);
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName = $fieldAccess;\n");
       addParameterStubs(callElement, (String name, CodeBuffer value) {
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
@@ skipping 56 matching lines @@
       needsClosureClass = true;
 
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
       emitBoundClosureClassHeader(mangledName, superName, boundClosureBuffer);
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
+          new ClosureInvocationElement(namer.CLOSURE_INVOCATION_NAME, member);
 
       String invocationName = namer.instanceMethodName(callElement);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
         arguments[i] = "p$i";
       }
       String joinedArgs = Strings.join(arguments, ", ");
       boundClosureBuffer.add(
           "$invocationName: function($joinedArgs) {");
       boundClosureBuffer.add(" return this.self[this.target]($joinedArgs);");
@@ skipping 35 matching lines @@
       getter = "this.${namer.getterName(member.getLibrary(), member.name)}()";
     } else {
       String name = namer.instanceFieldName(memberLibrary, member.name);
       getter = "this.$name";
     }
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         String invocationName =
             namer.instanceMethodInvocationName(memberLibrary, member.name,
                                                selector);
-        SourceString callName = Namer.CLOSURE_INVOCATION_NAME;
+        SourceString callName = namer.CLOSURE_INVOCATION_NAME;
         String closureCallName =
             namer.instanceMethodInvocationName(memberLibrary, callName,
                                                selector);
         List<String> arguments = <String>[];
         for (int i = 0; i < selector.argumentCount; i++) {
           arguments.add("arg$i");
         }
         String joined = Strings.join(arguments, ", ");
         CodeBuffer getterBuffer = new CodeBuffer();
         getterBuffer.add(
@@ skipping 416 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;