Fix compilation for Opera.

lib/compiler/implementation/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 42 matching lines @@
   String get defineClassName()
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName()
       => '${namer.ISOLATE}.\$finishClasses';
   String get finishIsolateConstructorName()
       => '${namer.ISOLATE}.\$finishIsolateConstructor';
   String get pendingClassesName()
       => '${namer.ISOLATE}.\$pendingClasses';
   String get isolatePropertiesName()
       => '${namer.ISOLATE}.${namer.ISOLATE_PROPERTIES}';
+  String get supportsProtoName()
+      => 'supportsProto';
 
   final String GETTER_SUFFIX = "?";
   final String SETTER_SUFFIX = "!";
   final String GETTER_SETTER_SUFFIX = "=";
 
   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);
   }
   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.
     //
     // Example:
     // defineClass("A", "B", ["x", "y"], {
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
     return """
-function(cls, superclass, fields, prototype) {
+function(cls, fields, prototype) {
   var generateGetterSetter = $generateGetterSetterFunction;
   var constructor;
   if (typeof fields == 'function') {
     constructor = fields;
   } else {
     var str = "function " + cls + "(";
     var body = "";
     for (var i = 0; i < fields.length; i++) {
       if (i != 0) str += ", ";
       var field = fields[i];
       field = generateGetterSetter(field, prototype);
       str += field;
       body += "this." + field + " = " + field + ";\\n";
     }
     str += ") {" + body + "}\\n";
     str += "return " + cls + ";";
     constructor = new Function(str)();
   }
-  $isolatePropertiesName[cls] = constructor;
   constructor.prototype = prototype;
-  if (superclass !== "") {
-    $pendingClassesName[cls] = superclass;
+  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.
+    // 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;
+}
+''';
   }
 
   String get finishClassesFunction() {
     // 'defineClass' does not require the classes to be constructed in order.
     // Classes are initially just stored in the 'pendingClasses' field.
     // 'finishClasses' takes all pending classes and sets up the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
     //  - the prototype's constructor field points to the JavaScript
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
     return '''
 function(collectedClasses) {
-  for (var collected in collectedClasses) {
-    if (Object.prototype.hasOwnProperty.call(collectedClasses, collected)) {
-      var desc = collectedClasses[collected];
-      $defineClassName(collected, desc.super, desc[''], desc);
+  for (var cls in collectedClasses) {
+    if (Object.prototype.hasOwnProperty.call(collectedClasses, cls)) {
+      var desc = collectedClasses[cls];
+      $isolatePropertiesName[cls] = $defineClassName(cls, desc[''], desc);
+      if (desc['super'] !== "") $pendingClassesName[cls] = desc['super'];
     }
   }
   var pendingClasses = $pendingClassesName;
 '''/* FinishClasses can be called multiple times. This means that we need to
       clear the pendingClasses property. */'''
   $pendingClassesName = {};
   var finishedClasses = {};
   function finishClass(cls) {
     if (finishedClasses[cls]) return;
     finishedClasses[cls] = true;
     var superclass = pendingClasses[cls];
 '''/* The superclass is only false (empty string) for Dart's Object class. */'''
     if (!superclass) return;
     finishClass(superclass);
     var constructor = $isolatePropertiesName[cls];
     var superConstructor = $isolatePropertiesName[superclass];
     var prototype = constructor.prototype;
-    if (prototype.__proto__) {
-'''/* On Firefox and Webkit browsers we can manipulate the __proto__
-      directly. */'''
+    if ($supportsProtoName) {
       prototype.__proto__ = superConstructor.prototype;
       prototype.constructor = constructor;
     } else {
-'''/* On the remaining browsers we need to instantiate an object with the
-      correct (internal) prototype set up correctly, and then copy the
-      members. */'''
       function tmp() {};
       tmp.prototype = superConstructor.prototype;
       var newPrototype = new tmp();
       constructor.prototype = newPrototype;
       newPrototype.constructor = constructor;
 '''/* Opera does not support 'getOwnPropertyNames'. Therefore we use
       hosOwnProperty instead. */'''
       var hasOwnProperty = Object.prototype.hasOwnProperty;
       for (var member in prototype) {
         if (member == '' || member == 'super') continue;
@@ skipping 45 matching lines @@
   isolatePrototype.constructor = newIsolate;
   newIsolate.${namer.ISOLATE_PROPERTIES} = isolateProperties;
   return newIsolate;
 }""";
   }
 
   void addDefineClassAndFinishClassFunctionsIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       String isolate = namer.ISOLATE;
       buffer.add("$defineClassName = $defineClassFunction;\n");
+      buffer.add(protoSupportCheck);
       buffer.add("$pendingClassesName = {};\n");
       buffer.add("$finishClassesName = $finishClassesFunction;\n");
     }
   }
 
   void emitFinishIsolateConstructor(CodeBuffer buffer) {
     String name = finishIsolateConstructorName;
     String value = finishIsolateConstructorFunction;
     buffer.add("$name = $value;\n");
   }
@@ skipping 454 matching lines @@
       // Create a new closure class.
       SourceString name = const SourceString("BoundClosure");
       ClassElement closureClassElement =
           new ClosureClassElement(name, compiler, 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("$defineClassName('$mangledName', '$superName', ");
-      boundClosureBuffer.add("['self', 'target'], {\n");
-
+      boundClosureBuffer.add("""
+$classesCollector.$mangledName = {'':
+ ['self', 'target'],
+ 'super': '$superName',
+""");
       // 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(member.getLibrary(),
                                    callElement.name, parameterCount);
       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);");
       boundClosureBuffer.add(" }");
       addParameterStubs(callElement, (String stubName, CodeBuffer memberValue) {
         boundClosureBuffer.add(',\n $stubName: $memberValue');
       });
-      boundClosureBuffer.add("\n});\n");
+      boundClosureBuffer.add("\n};\n");
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (!hasOptionalParameters) {
         boundClosureCache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
@@ skipping 283 matching lines @@
       // the classesCollector variable.
       classesCollector = 'classesCollector should not be used from now on';
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add(
         'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
 
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       mainBuffer.add('function init() {\n');
-      mainBuffer.add('  $isolateProperties = {};\n');
+      mainBuffer.add('$isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
 
       if (generateSourceMap) {
         SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
         String sourceMap = sourceMapBuilder.build(compiledFile);
         // TODO(podivilov): We should find a better way to return source maps to
         // compiler. Using diagnostic handler for that purpose is a temporary
@@ skipping 13 matching lines @@
         sourceName = token.slowToString();
       }
       int totalOffset = bufferOffset + offset;
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, totalOffset);
     });
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);