Library privacy.

dart/frog/leg/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,
                            FunctionElement other)
-      : super.from(name, other, null);
+      : super.from(name, other, other.enclosingElement);
 
   isInstanceMember() => true;
 }
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
@@ skipping 47 matching lines @@
     FunctionParameters parameters = member.computeParameters(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
       return;
     }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName =
-        namer.instanceMethodInvocationName(member.name, selector);
+        namer.instanceMethodInvocationName(member.getLibrary(), member.name,
+                                           selector);
     buffer.add('${attachTo(invocationName)} = function(');
 
     // The parameters that this stub takes.
     List<String> parametersBuffer = new List<String>(selector.argumentCount);
     // The arguments that will be passed to the real method.
     List<String> argumentsBuffer = new List<String>(parameters.parameterCount);
 
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, [c, d]);
@@ skipping 109 matching lines @@
       FunctionElement function = member;
       FunctionParameters parameters = function.computeParameters(compiler);
       if (!parameters.optionalParameters.isEmpty()) {
         addParameterStubs(member, attachTo, buffer, isNative: isNative);
       }
     } else if (member.kind === ElementKind.FIELD) {
       // TODO(ngeoffray): Have another class generate the code for the
       // fields.
       if ((member.modifiers === null || !member.modifiers.isFinal()) &&
           compiler.universe.invokedSetters.contains(member.name)) {
-        String setterName = namer.setterName(member.name);
+        String setterName = namer.setterName(member.getLibrary(), member.name);
         String name =
             isNative ? member.name.slowToString() : namer.getName(member);
         buffer.add('${attachTo(setterName)} = function(v){\n');
         buffer.add('  this.$name = v;\n};\n');
       }
       if (compiler.universe.invokedGetters.contains(member.name)) {
-        String getterName = namer.getterName(member.name);
+        String getterName = namer.getterName(member.getLibrary(), member.name);
         String name =
             isNative ? member.name.slowToString() : namer.getName(member);
         buffer.add('${attachTo(getterName)} = function(){\n');
         buffer.add('  return this.$name;\n};\n');
       }
     } else {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, attachTo, buffer);
   }
 
   bool generateFieldInits(ClassElement classElement,
                           StringBuffer argumentsBuffer,
                           StringBuffer bodyBuffer) {
     bool isFirst = true;
     do {
       // TODO(floitsch): make sure there are no name clashes.
       String className = namer.getName(classElement);
 
       void generateFieldInit(Element member) {
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
           if (!isFirst) argumentsBuffer.add(', ');
           isFirst = false;
-          String memberName = namer.instanceFieldName(member.name);
+          String memberName = namer.instanceFieldName(member.getLibrary(),
+                                                      member.name);
           argumentsBuffer.add('${className}_$memberName');
           bodyBuffer.add('  this.$memberName = ${className}_$memberName;\n');
         }
       }
 
       for (Element element in classElement.members) {
         generateFieldInit(element);
       }
       for (Element element in classElement.backendMembers) {
         generateFieldInit(element);
@@ skipping 118 matching lines @@
     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);
       String staticName = namer.isolatePropertyAccess(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
-          namer.instanceMethodName(callElement.name, parameterCount);
+          namer.instanceMethodName(element.getLibrary(), callElement.name,
+                                   parameterCount);
       buffer.add("$staticName.$invocationName = $staticName;\n");
       addParameterStubs(callElement, (name) => '$staticName.$name', buffer);
     }
   }
 
   void emitDynamicFunctionGetter(StringBuffer buffer,
                                  String attachTo(String invocationName),
                                  FunctionElement member) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
@@ skipping 30 matching lines @@
 
     // 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);
 
     int parameterCount = member.parameterCount(compiler);
     String invocationName =
-        namer.instanceMethodName(callElement.name, parameterCount);
-    String targetName = namer.instanceMethodName(member.name, parameterCount);
+        namer.instanceMethodName(member.getLibrary(),
+                                 callElement.name, parameterCount);
+    String targetName = namer.instanceMethodName(member.getLibrary(),
+                                                 member.name, parameterCount);
     List<String> arguments = new List<String>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       arguments[i] = "arg$i";
     }
     String joinedArgs = Strings.join(arguments, ", ");
     buffer.add("$prototype.$invocationName = function($joinedArgs) {\n");
     buffer.add("  return this.self.$targetName($joinedArgs);\n");
     buffer.add("};\n");
     addParameterStubs(callElement, (name) => '$prototype.$name', buffer);
 
     // And finally the getter.
-    String getterName = namer.getterName(member.name);
+    String getterName = namer.getterName(member.getLibrary(), member.name);
     String closureClass = namer.isolateAccess(closureClassElement);
     buffer.add("${attachTo(getterName)} = function() {\n");
     buffer.add("  return new $closureClass(this);\n");
     buffer.add("};\n");
   }
 
   void emitCallStubForGetter(StringBuffer buffer,
                              String attachTo(String name),
                              Element member,
                              Set<Selector> selectors) {
     String getter;
     if (member.kind == ElementKind.GETTER) {
-      getter = "this.${namer.getterName(member.name)}()";
+      getter = "this.${namer.getterName(member.getLibrary(), member.name)}()";
     } else {
-      getter = "this.${namer.instanceFieldName(member.name)}";
+      getter =
+          "this.${namer.instanceFieldName(member.getLibrary(), member.name)}";
     }
     for (Selector selector in selectors) {
       String invocationName =
-          namer.instanceMethodInvocationName(member.name, selector);
+          namer.instanceMethodInvocationName(member.getLibrary(), member.name,
+                                             selector);
       SourceString callName = Namer.CLOSURE_INVOCATION_NAME;
       String closureCallName =
-          namer.instanceMethodInvocationName(callName, selector);
+          namer.instanceMethodInvocationName(member.getLibrary(), callName,
+                                             selector);
       List<String> arguments = <String>[];
       for (int i = 0; i < selector.argumentCount; i++) {
         arguments.add("arg$i");
       }
       String joined = Strings.join(arguments, ", ");
       buffer.add("${attachTo(invocationName)} = function($joined) {\n");
       buffer.add("  return $getter.$closureCallName($joined);\n");
       buffer.add("};\n");
     }
   }
@@ skipping 73 matching lines @@
 
   void emitNoSuchMethodCalls(StringBuffer buffer) {
     // Do not generate no such method calls if there is no class.
     if (compiler.universe.instantiatedClasses.isEmpty()) return;
 
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     String className = namer.isolatePropertyAccess(objectClass);
     String prototype = '$className.prototype';
     String noSuchMethodName =
-        namer.instanceMethodName(Compiler.NO_SUCH_METHOD, 2);
+        namer.instanceMethodName(null, Compiler.NO_SUCH_METHOD, 2);
+    Collection<LibraryElement> libraries =
+      compiler.universe.libraries.getValues();
 
     void generateMethod(String methodName, String jsName, Selector selector) {
       buffer.add('$prototype.$jsName = function');
       StringBuffer args = new StringBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         if (i != 0) args.add(', ');
         args.add('arg$i');
       }
       // We need to check if the object has a noSuchMethod. If not, it
       // means the object is a native object, and we can just call our
       // generic noSuchMethod. Note that when calling this method, the
       // 'this' object is not a Dart object.
       buffer.add(' ($args) {\n');
       buffer.add('  return this.$noSuchMethodName\n');
       buffer.add("      ? this.$noSuchMethodName('$methodName', [$args])\n");
       buffer.add("      : $objectClassName.prototype.$noSuchMethodName.call(");
       buffer.add("this, '$methodName', [$args])\n");
       buffer.add('}\n');
     }
 
     compiler.universe.invokedNames.forEach((SourceString methodName,
                                             Set<Selector> selectors) {
       if (objectClass.lookupLocalMember(methodName) === null
           && methodName != Namer.OPERATOR_EQUALS) {
         for (Selector selector in selectors) {
-          String jsName =
-              namer.instanceMethodInvocationName(methodName, selector);
-          generateMethod(methodName.slowToString(), jsName, selector);
+          if (methodName.isPrivate()) {
+            for (LibraryElement lib in libraries) {
+              String jsName =
+                namer.instanceMethodInvocationName(lib, methodName, selector);
+              generateMethod(methodName.slowToString(), jsName, selector);
+            }
+          } else {
+            String jsName =
+              namer.instanceMethodInvocationName(null, methodName, selector);
+            generateMethod(methodName.slowToString(), jsName, selector);
+          }
         }
       }
     });
 
     compiler.universe.invokedGetters.forEach((SourceString getterName) {
-      String jsName = namer.getterName(getterName);
-      generateMethod('get ${getterName.slowToString()}', jsName,
-                     Selector.GETTER);
+      if (getterName.isPrivate()) {
+        for (LibraryElement lib in libraries) {
+          String jsName = namer.getterName(lib, getterName);
+          generateMethod('get ${getterName.slowToString()}', jsName,
+                         Selector.GETTER);
+        }
+      } else {
+        String jsName = namer.getterName(null, getterName);
+        generateMethod('get ${getterName.slowToString()}', jsName,
+                       Selector.GETTER);
+      }
     });
 
     compiler.universe.invokedSetters.forEach((SourceString setterName) {
-      String jsName = namer.setterName(setterName);
-      generateMethod('set ${setterName.slowToString()}', jsName,
-                     Selector.SETTER);
+      if (setterName.isPrivate()) {
+        for (LibraryElement lib in libraries) {
+          String jsName = namer.setterName(lib, setterName);
+          generateMethod('set ${setterName.slowToString()}', jsName,
+                         Selector.SETTER);
+        }
+      } else {
+        String jsName = namer.setterName(null, setterName);
+        generateMethod('set ${setterName.slowToString()}', jsName,
+                       Selector.SETTER);
+      }
     });
   }
   
   String buildIsolateSetup(Element appMain, Element isolateMain) {
     String mainAccess = "${namer.isolateAccess(appMain)}";
     String currentIsolate = "${namer.CURRENT_ISOLATE}";
     String mainEnsureGetter = '';
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     if (!compiler.universe.staticFunctionsNeedingGetter.contains(appMain)) {
@@ skipping 40 matching lines @@
             compiler.isolateLibrary.find(Compiler.START_ROOT_ISOLATE);
         buffer.add(buildIsolateSetup(main, isolateMain));
       } else {
         buffer.add('${namer.isolateAccess(main)}();\n');
       }
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }