Throw when reflecting on elements not covered by a `MirrorsUsed` annotation.

sdk/lib/_internal/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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 269 matching lines @@
   // characters.
   static const FIELD_CODE_CHARACTERS = r"<=>?@{|}~%&'()*";
   static const NO_FIELD_CODE = 0;
   static const FIRST_FIELD_CODE = 1;
   static const RANGE1_FIRST = 0x3c;   //  <=>?@    encodes 1..5
   static const RANGE1_LAST = 0x40;
   static const RANGE2_FIRST = 0x7b;   //  {|}~     encodes 6..9
   static const RANGE2_LAST = 0x7e;
   static const RANGE3_FIRST = 0x25;   //  %&'()*+  encodes 10..16
   static const RANGE3_LAST = 0x2b;
+  static const REFLECTION_MARKER = 0x2d;
 
   jsAst.FunctionDeclaration get generateAccessorFunction {
     const RANGE1_SIZE = RANGE1_LAST - RANGE1_FIRST + 1;
     const RANGE2_SIZE = RANGE2_LAST - RANGE2_FIRST + 1;
     const RANGE1_ADJUST = - (FIRST_FIELD_CODE - RANGE1_FIRST);
     const RANGE2_ADJUST = - (FIRST_FIELD_CODE + RANGE1_SIZE - RANGE2_FIRST);
     const RANGE3_ADJUST =
         - (FIRST_FIELD_CODE + RANGE1_SIZE + RANGE2_SIZE - RANGE3_FIRST);
 
     String receiverParamName = compiler.enableMinification ? "r" : "receiver";
     String valueParamName = compiler.enableMinification ? "v" : "value";
+    String reflectableField = namer.reflectableField;
 
     // function generateAccessor(field, prototype) {
     jsAst.Fun fun = js.fun(['field', 'prototype'], [
       js('var len = field.length'),
       js('var code = field.charCodeAt(len - 1)'),
+      js('var reflectable = false'),
+      js.if_('code == $REFLECTION_MARKER', [
+          js('len--'),
+          js('code = field.charCodeAt(len - 1)'),
+          js('field = field.substring(0, len)'),
+          js('reflectable = true')
+      ]),
       js('code = ((code >= $RANGE1_FIRST) && (code <= $RANGE1_LAST))'
           '    ? code - $RANGE1_ADJUST'
           '    : ((code >= $RANGE2_FIRST) && (code <= $RANGE2_LAST))'
           '      ? code - $RANGE2_ADJUST'
           '      : ((code >= $RANGE3_FIRST) && (code <= $RANGE3_LAST))'
           '        ? code - $RANGE3_ADJUST'
           '        : $NO_FIELD_CODE'),
 
       // if (needsAccessor) {
       js.if_('code', [
         js('var getterCode = code & 3'),
         js('var setterCode = code >> 2'),
         js('var accessorName = field = field.substring(0, len - 1)'),
 
         js('var divider = field.indexOf(":")'),
         js.if_('divider > 0', [  // Colon never in first position.
           js('accessorName = field.substring(0, divider)'),
           js('field = field.substring(divider + 1)')
         ]),
 
         // if (needsGetter) {
         js.if_('getterCode', [
           js('var args = (getterCode & 2) ? "$receiverParamName" : ""'),
           js('var receiver = (getterCode & 1) ? "this" : "$receiverParamName"'),
           js('var body = "return " + receiver + "." + field'),
           js('prototype["${namer.getterPrefix}" + accessorName] = '
-                 'new Function(args, body)')
+                 'new Function(args, body)'),
+          js.if_('!reflectable', [
+                 js('prototype["${namer.getterPrefix}" + accessorName].'
+                    '$reflectableField = false')])
         ]),
 
         // if (needsSetter) {
         js.if_('setterCode', [
           js('var args = (setterCode & 2)'
               '  ? "$receiverParamName,${_}$valueParamName"'
               '  : "$valueParamName"'),
           js('var receiver = (setterCode & 1) ? "this" : "$receiverParamName"'),
           js('var body = receiver + "." + field + "$_=$_$valueParamName"'),
           js('prototype["${namer.setterPrefix}" + accessorName] = '
-                 'new Function(args, body)')
+                 'new Function(args, body)'),
+          js.if_('!reflectable', [
+                 js('prototype["${namer.setterPrefix}" + accessorName].'
+                    '$reflectableField = false')])
         ]),
 
       ]),
 
       // return field;
       js.return_('field')
     ]);
 
     return new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('generateAccessor'),
@@ skipping 738 matching lines @@
     } else {
       body = [js.return_(js('this')[namer.getName(member)](argumentsBuffer))];
     }
 
     jsAst.Fun function = js.fun(parametersBuffer, body);
 
     defineStub(invocationName, function);
 
     String reflectionName = getReflectionName(selector, invocationName);
     if (reflectionName != null) {
-      defineStub('+$reflectionName', js('0'));
+      var reflectable =
+          js(backend.isAccessibleByReflection(member) ? '1' : '0');
+      defineStub('+$reflectionName', reflectable);
     }
   }
 
   void addParameterStubs(FunctionElement member,
                          DefineStubFunction defineStub) {
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
     //
     // We may have multiple ways of calling foo:
@@ skipping 150 matching lines @@
       jsAst.Expression code = backend.generatedCode[member];
       if (code == null) return;
       String name = namer.getName(member);
       if (backend.isInterceptedMethod(member)) {
         interceptorInvocationNames.add(name);
       }
       code = extendWithMetadata(member, code);
       builder.addProperty(name, code);
       String reflectionName = getReflectionName(member, name);
       if (reflectionName != null) {
-        builder.addProperty('+$reflectionName', js('0'));
+        var reflectable =
+            js(backend.isAccessibleByReflection(member) ? '1' : '0');
+        builder.addProperty('+$reflectionName', reflectable);
       }
       code = backend.generatedBailoutCode[member];
       if (code != null) {
         builder.addProperty(namer.getBailoutName(member), code);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty) {
         addParameterStubs(member, builder.addProperty);
       }
@@ skipping 34 matching lines @@
 
   String getReflectionNameInternal(elementOrSelector, String mangledName) {
     String name = elementOrSelector.name.slowToString();
     if (elementOrSelector.isGetter()) return name;
     if (elementOrSelector.isSetter()) {
       if (!mangledName.startsWith(namer.setterPrefix)) return '$name=';
       String base = mangledName.substring(namer.setterPrefix.length);
       String getter = '${namer.getterPrefix}$base';
       mangledFieldNames[getter] = name;
       recordedMangledNames.add(getter);
-      return null;
+      // TODO(karlklose,ahe): we do not actually need to store information
+      // about the name of this setter in the output, but it is needed for
+      // marking the function as invokable by reflection.
+      return '$name=';
     }
     if (elementOrSelector is Selector
         || elementOrSelector.isFunction()
         || elementOrSelector.isConstructor()) {
       int requiredParameterCount;
       int optionalParameterCount;
       String namedArguments = '';
       bool isConstructor = false;
       if (elementOrSelector is Selector) {
         Selector selector = elementOrSelector;
@@ skipping 515 matching lines @@
               }
             }
             int code = getterCode + (setterCode << 2);
             if (code == 0) {
               compiler.reportInternalError(
                   field, 'Internal error: code is 0 ($element/$field)');
             } else {
               buffer.write(FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE]);
             }
           }
+          if (backend.isAccessibleByReflection(field)) {
+            buffer.write(new String.fromCharCode(REFLECTION_MARKER));
+          }
         }
       });
     }
 
     bool fieldsAdded = buffer.length > bufferClassLength;
     String compactClassData = buffer.toString();
     jsAst.Expression classDataNode = js.string(compactClassData);
     if (hasMetadata) {
       fieldMetadata.insert(0, classDataNode);
       classDataNode = new jsAst.ArrayInitializer.from(fieldMetadata);
@@ skipping 419 matching lines @@
             .toSet();
 
     for (Element element in Elements.sortedByPosition(elements)) {
       CodeBuffer buffer = bufferForElement(element, eagerBuffer);
       jsAst.Expression code = backend.generatedCode[element];
       String name = namer.getName(element);
       code = extendWithMetadata(element, code);
       emitStaticFunction(buffer, name, code);
       String reflectionName = getReflectionName(element, name);
       if (reflectionName != null) {
-        buffer.write(',$n$n"+$reflectionName":${_}0');
+        var reflectable = backend.isAccessibleByReflection(element) ? 1 : 0;
+        buffer.write(',$n$n"+$reflectionName":${_}$reflectable');
       }
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
         emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
       }
     }
 
     if (!pendingElementsWithBailouts.isEmpty) {
       addComment('pendingElementsWithBailouts', eagerBuffer);
@@ skipping 1709 matching lines @@
   // TODO(ahe): Remove this when deferred loading is fully implemented.
   void warnNotImplemented(Element element, String message) {
     compiler.reportMessage(compiler.spanFromSpannable(element),
                            MessageKind.GENERIC.error({'text': message}),
                            api.Diagnostic.WARNING);
   }
 
   // TODO(ahe): This code should be integrated in finishClasses.
   String getReflectionDataParser() {
     String metadataField = '"${namer.metadataField}"';
+    String reflectableField = namer.reflectableField;
     return '''
 (function (reflectionData) {
 '''
 // [map] returns an object literal that V8 shouldn't try to optimize with a
 // hidden class. This prevents a potential performance problem where V8 tries
 // to build a hidden class for an object used as a hashMap.
 '''
   function map(x){x={x:x};delete x.x;return x}
   if (!init.libraries) init.libraries = [];
   if (!init.mangledNames) init.mangledNames = map();
@@ skipping 28 matching lines @@
     var functions = [];
     function processStatics(descriptor) {
       for (var property in descriptor) {
         if (!hasOwnProperty.call(descriptor, property)) continue;
         if (property === "") continue;
         var element = descriptor[property];
         var firstChar = property.substring(0, 1);
         var previousProperty;
         if (firstChar === "+") {
           mangledGlobalNames[previousProperty] = property.substring(1);
-          if (element && element.length) ''' // Breaking long line.
+          descriptor[previousProperty].''' // Break long line.
+'''$reflectableField = (descriptor[property] == 1);
+          if (element && element.length) ''' // Break long line.
 '''init.interfaces[previousProperty] = element;
         } else if (firstChar === "@") {
           property = property.substring(1);
           ${namer.CURRENT_ISOLATE}[property][$metadataField] = element;
         } else if (typeof element === "function") {
           ${namer.CURRENT_ISOLATE}[previousProperty = property] = element;
           functions.push(property);
         } else {
           previousProperty = property;
           var newDesc = {};
           var previousProp;
           for (var prop in element) {
             if (!hasOwnProperty.call(element, prop)) continue;
             firstChar = prop.substring(0, 1);
             if (prop === "static") {
               processStatics(init.statics[property] = element[prop]);
             } else if (firstChar === "+") {
               mangledNames[previousProp] = prop.substring(1);
+              element[previousProp].''' // Break long line.
+'''$reflectableField = (element[prop] == 1);
             } else if (firstChar === "@" && prop !== "@") {
               newDesc[prop.substring(1)][$metadataField] = element[prop];
             } else {
               newDesc[previousProp = prop] = element[prop];
             }
           }
           $classesCollector[property] = newDesc;
           classes.push(property);
         }
       }
@@ skipping 11 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // 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].
 """;