Add a content-security-policy (CSP) flag.

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 29 matching lines @@
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Map<int, String> boundClosureCache;
   Set<ClassElement> checkedClasses;
 
   final bool generateSourceMap;
 
-  CodeEmitterTask(Compiler compiler, Namer namer,
-                  [bool generateSourceMap = false])
+  CodeEmitterTask(Compiler compiler, Namer namer, this.generateSourceMap)
       : boundClosureBuffer = new CodeBuffer(),
         mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
-        generateSourceMap = generateSourceMap,
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void computeRequiredTypeChecks() {
     assert(checkedClasses == null);
     checkedClasses = new Set<ClassElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
       if (t is InterfaceType) checkedClasses.add(t.element);
@@ skipping 91 matching lines @@
   constructor.prototype = prototype;
   return constructor;
 }""";
   }
 
   /** Needs defineClass to be defined. */
   String get protoSupportCheck {
     // On Firefox and Webkit browsers we can manipulate the __proto__
     // directly. Opera claims to have __proto__ support, but it is buggy.
     // So we have to do more checks.
+    // Opera bug was filed as DSK-370158, and fixed as CORE-47615
+    // (http://my.opera.com/desktopteam/blog/2012/07/20/more-12-01-fixes).
     // If the browser does not support __proto__ we need to instantiate an
     // object with the correct (internal) prototype set up correctly, and then
     // copy the members.
 
     return '''
 var $supportsProtoName = false;
 var tmp = $defineClassName('c', ['f?'], {}).prototype;
 if (tmp.__proto__) {
   tmp.__proto__ = {};
   if (typeof tmp.get\$f !== "undefined") $supportsProtoName = true;
@@ skipping 435 matching lines @@
       if (!parameters.optionalParameters.isEmpty()) {
         addParameterStubs(member, defineInstanceMember);
       }
     } else if (!member.isField()) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, defineInstanceMember);
   }
 
-  String generateCheckedSetter(Element member, String fieldName) {
-    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 null;
-    } else {
-      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)}'";
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [classElement] must be a declaration element.
+   */
+  void emitInstanceMembers(ClassElement classElement,
+                           CodeBuffer buffer,
+                           bool needsLeadingComma) {
+    assert(invariant(classElement, classElement.isDeclaration));
+    bool needsComma = needsLeadingComma;
+    void defineInstanceMember(String name, CodeBuffer memberBuffer) {
+      if (needsComma) buffer.add(',');
+      needsComma = true;
+      buffer.add('\n');
+      buffer.add(' $name: ');
+      buffer.add(memberBuffer);
+    }
+
+    classElement.implementation.forEachMember(
+        (ClassElement enclosing, Element member) {
+          assert(invariant(classElement, member.isDeclaration));
+          if (member.isInstanceMember()) {
+            addInstanceMember(member, defineInstanceMember);
+          }
+        },
+        includeBackendMembers: true);
+
+    generateIsTestsOn(classElement, (ClassElement other) {
+      String code;
+      if (other.isObject(compiler)) return;
+      if (nativeEmitter.requiresNativeIsCheck(other)) {
+        code = 'function() { return true; }';
+      } else {
+        code = 'true';
       }
-      return " set\$$fieldName: function(v) { "
-          "this.$fieldName = $helperName(v$additionalArgument); }";
+      CodeBuffer typeTestBuffer = new CodeBuffer();
+      typeTestBuffer.add(code);
+      defineInstanceMember(namer.operatorIs(other), typeTestBuffer);
+    });
+
+    if (identical(classElement, compiler.objectClass)
+        && compiler.enabledNoSuchMethod) {
+      // Emit the noSuchMethod handlers on the Object prototype now,
+      // so that the code in the dynamicFunction helper can find
+      // them. Note that this helper is invoked before analyzing the
+      // full JS script.
+      if (!nativeEmitter.handleNoSuchMethod) {
+        emitNoSuchMethodHandlers(defineInstanceMember);
+      }
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
-  List<String> emitClassFields(ClassElement classElement, CodeBuffer buffer) {
+  void visitClassFields(ClassElement classElement,
+                        void addField(Element member,
+                                      String name,
+                                      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);
-    List<String> checkedSetters = <String>[];
 
-    bool isFirstField = true;
-    void addField(ClassElement enclosingClass, Element member) {
+    void visitField(ClassElement enclosingClass, Element member) {
       assert(!member.isNative());
       assert(invariant(classElement, member.isDeclaration));
 
       LibraryElement library = member.getLibrary();
       SourceString name = member.name;
       bool isPrivate = name.isPrivate();
       // See if we can dynamically create getters and setters.
       // We can only generate getters and setters for [classElement] since
       // the fields of super classes could be overwritten with getters or
       // setters.
-      bool needsDynamicGetter = false;
-      bool needsDynamicSetter = false;
+      bool needsGetter = false;
+      bool needsSetter = false;
       // We need to name shadowed fields differently, so they don't clash with
       // the non-shadowed field.
       bool isShadowed = false;
       if (identical(enclosingClass, classElement)) {
-        needsDynamicGetter = instanceFieldNeedsGetter(member);
-        needsDynamicSetter = instanceFieldNeedsSetter(member);
+        needsGetter = instanceFieldNeedsGetter(member);
+        needsSetter = instanceFieldNeedsSetter(member);
       } else {
         isShadowed = classElement.isShadowedByField(member);
       }
 
       if ((isInstantiated && !enclosingClass.isNative())
-          || needsDynamicGetter
-          || needsDynamicSetter) {
-        if (isFirstField) {
-          isFirstField = false;
-        } else {
-          buffer.add(", ");
-        }
+          || needsGetter
+          || needsSetter) {
         String fieldName = isShadowed
             ? namer.shadowedFieldName(member)
             : namer.getName(member);
-        if (needsDynamicSetter && compiler.enableTypeAssertions) {
-          String setter = generateCheckedSetter(member, fieldName);
-          if (setter != null) {
-            needsDynamicSetter = false;
-            checkedSetters.add(setter);
-          }
+        bool needsCheckedSetter = false;
+        if (needsSetter && compiler.enableTypeAssertions
+            && canGenerateCheckedSetter(member)) {
+          needsCheckedSetter = true;
+          needsSetter = false;
         }
         // Getters and setters with suffixes will be generated dynamically.
-        buffer.add('"$fieldName');
-        if (needsDynamicGetter || needsDynamicSetter) {
-          if (needsDynamicGetter && needsDynamicSetter) {
-            buffer.add(GETTER_SETTER_SUFFIX);
-          } else if (needsDynamicGetter) {
-            buffer.add(GETTER_SUFFIX);
-          } else {
-            buffer.add(SETTER_SUFFIX);
-          }
-        }
-        buffer.add('"');
+        addField(member,
+                 fieldName,
+                 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(
-        addField,
+        visitField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
-    return checkedSetters;
+  }
+
+  void generateGetter(Element member, String fieldName, CodeBuffer buffer) {
+    String getterName = namer.getterName(member.getLibrary(), member.name);
+    buffer.add("$getterName: function() { return this.$fieldName; }");
+  }
+
+  void generateSetter(Element member, String fieldName, CodeBuffer buffer) {
+    String setterName = namer.setterName(member.getLibrary(), member.name);
+    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,
+                             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);
+    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,
+                                    bool needsGetter,
+                                    bool needsSetter,
+                                    bool needsCheckedSetter) {
+      if (isFirstField) {
+        isFirstField = false;
+      } else {
+        buffer.add(", ");
+      }
+      buffer.add('"$name');
+      if (needsGetter && needsSetter) {
+        buffer.add(GETTER_SETTER_SUFFIX);
+      } else if (needsGetter) {
+        buffer.add(GETTER_SUFFIX);
+      } else if (needsSetter) {
+        buffer.add(SETTER_SUFFIX);
+      }
+      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,
+                                    bool needsGetter,
+                                    bool needsSetter,
+                                    bool needsCheckedSetter) {
+      if (needsCheckedSetter) {
+        assert(!needsSetter);
+        if (!omitLeadingComma) {
+          buffer.add(",\n ");
+        } else {
+          omitLeadingComma = false;
+        }
+        generateCheckedSetter(member, name, buffer);
+      }
+    });
   }
 
   /**
-   * Documentation wanted -- johnniwinther
-   *
-   * Invariant: [classElement] must be a declaration element.
-   */
-  void emitInstanceMembers(ClassElement classElement,
-                           CodeBuffer buffer,
-                           bool needsLeadingComma) {
-    assert(invariant(classElement, classElement.isDeclaration));
-    bool needsComma = needsLeadingComma;
-    void defineInstanceMember(String name, CodeBuffer memberBuffer) {
-      if (needsComma) buffer.add(',');
-      needsComma = true;
-      buffer.add('\n');
-      buffer.add(' $name: ');
-      buffer.add(memberBuffer);
-    }
-
-    classElement.implementation.forEachMember(
-        (ClassElement enclosing, Element member) {
-          assert(invariant(classElement, member.isDeclaration));
-          if (member.isInstanceMember()) {
-            addInstanceMember(member, defineInstanceMember);
-          }
-        },
-        includeBackendMembers: true);
-
-    generateIsTestsOn(classElement, (ClassElement other) {
-      String code;
-      if (other.isObject(compiler)) return;
-      if (nativeEmitter.requiresNativeIsCheck(other)) {
-        code = 'function() { return true; }';
-      } else {
-        code = 'true';
-      }
-      CodeBuffer typeTestBuffer = new CodeBuffer();
-      typeTestBuffer.add(code);
-      defineInstanceMember(namer.operatorIs(other), typeTestBuffer);
-    });
-
-    if (identical(classElement, compiler.objectClass)
-        && compiler.enabledNoSuchMethod) {
-      // Emit the noSuchMethod handlers on the Object prototype now,
-      // so that the code in the dynamicFunction helper can find
-      // them. Note that this helper is invoked before analyzing the
-      // full JS script.
-      if (!nativeEmitter.handleNoSuchMethod) {
-        emitNoSuchMethodHandlers(defineInstanceMember);
-      }
-    }
-  }
-
-  /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void generateClass(ClassElement classElement, CodeBuffer buffer) {
     assert(invariant(classElement, classElement.isDeclaration));
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement);
       return;
     } else {
       // TODO(ngeoffray): Instead of switching between buffer, we
       // should create code sections, and decide where to emit them at
       // the end.
       buffer = mainBuffer;
     }
 
     needsDefineClass = true;
     String className = namer.getName(classElement);
     ClassElement superclass = classElement.superclass;
     String superName = "";
     if (superclass != null) {
       superName = namer.getName(superclass);
     }
-    String constructorName = namer.safeName(classElement.name.slowToString());
 
-    buffer.add('$classesCollector.$className = {"":\n');
-    buffer.add(' [');
-    List<String> checkedSetters = emitClassFields(classElement, buffer);
-    buffer.add('],\n');
+    buffer.add('$classesCollector.$className = {');
+    emitClassConstructor(classElement, buffer);
+    emitClassFields(classElement, buffer);
     // TODO(floitsch): the emitInstanceMember should simply always emit a ',\n'.
     // That does currently not work because the native classes have a different
     // syntax.
-    buffer.add(' "super": "$superName"');
-    if (!checkedSetters.isEmpty()) {
-      buffer.add(',\n');
-      buffer.add('${Strings.join(checkedSetters, ",\n")}');
-    }
+    buffer.add(',\n "super": "$superName"');
+    emitClassGettersSetters(classElement, buffer);
     emitInstanceMembers(classElement, buffer, true);
     buffer.add('\n};\n\n');
   }
 
   /**
    * Generate "is tests" for [cls]: itself, and the "is tests" for the
    * classes it implements. We don't need to add the "is tests" of the
    * super class because they will be inherited at runtime.
    */
   void generateIsTestsOn(ClassElement cls,
@@ skipping 144 matching lines @@
       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;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
   }
 
+  void emitBoundClosureClassHeader(String mangledName,
+                             String superName,
+                             CodeBuffer buffer) {
+    buffer.add("""
+$classesCollector.$mangledName = {'':
+['self', 'target'],
+'super': '$superName',
+""");
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineMemberFunction defineInstanceMember) {
     assert(invariant(member, member.isDeclaration));
     // 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 26 matching lines @@
       // Create a new closure class.
       SourceString name = const SourceString("BoundClosure");
       ClassElement closureClassElement = new ClosureClassElement(
           name, compiler, member, member.getCompilationUnit());
       String mangledName = namer.getName(closureClassElement);
       String superName = namer.getName(closureClassElement.superclass);
       needsClosureClass = true;
 
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
-      boundClosureBuffer.add("""
-$classesCollector.$mangledName = {'':
- ['self', 'target'],
- 'super': '$superName',
-""");
+      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);
 
       String invocationName = namer.instanceMethodName(callElement);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
@@ skipping 475 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].
 """;