Support checked mode for field setters.

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 51 matching lines @@
       => '${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;
-}""";
+  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) {
@@ skipping 325 matching lines @@
       if (!parameters.optionalParameters.isEmpty()) {
         addParameterStubs(member, defineInstanceMember);
       }
     } else if (member.kind !== ElementKind.FIELD) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, defineInstanceMember);
   }
 
-  Set<Element> emitClassFields(ClassElement classElement, CodeBuffer buffer) {
+  String generateCheckedSetter(Element member, String fieldName) {
+    Type 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);
+      Element helperElement = compiler.findHelper(helper);
+      String helperName = compiler.namer.isolateAccess(helperElement);
+      String additionalArgument = compiler.namer.operatorIs(type.element);
+      return " set\$$fieldName: function(v) { "
+          "this.$fieldName = $helperName(v, '$additionalArgument'); }";
+    }
+  }
+
+  List<String> emitClassFields(ClassElement classElement, CodeBuffer buffer) {
     // 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) {
       assert(!member.isNative());
 
       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
@@ skipping 15 matching lines @@
           || needsDynamicGetter
           || needsDynamicSetter) {
         if (isFirstField) {
           isFirstField = false;
         } else {
           buffer.add(", ");
         }
         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);
+          }
+        }
         // 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('"');
       }
     }
 
     // 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.forEachInstanceField(
         addField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
+    return checkedSetters;
   }
 
   void emitInstanceMembers(ClassElement classElement,
                            CodeBuffer buffer,
                            bool needsLeadingComma) {
     bool needsComma = needsLeadingComma;
     void defineInstanceMember(String name, CodeBuffer memberBuffer) {
       if (needsComma) buffer.add(',');
       needsComma = true;
       buffer.add('\n');
@@ skipping 47 matching lines @@
     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(' [');
-    emitClassFields(classElement, buffer);
+    List<String> checkedSetters = emitClassFields(classElement, buffer);
     buffer.add('],\n');
     // 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")}');
+    }
     emitInstanceMembers(classElement, buffer, true);
     buffer.add('\n};\n\n');
   }
 
   void generateTypeTests(ClassElement cls,
                          void generateTypeTest(ClassElement element)) {
     if (compiler.codegenWorld.isChecks.contains(cls)) {
       generateTypeTest(cls);
     }
     generateInterfacesIsTests(cls, generateTypeTest, new Set<Element>());
@@ skipping 586 matching lines @@
         sourceName = token.slowToString();
       }
       int totalOffset = bufferOffset + offset;
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, totalOffset);
     });
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);