Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name => 'SSA code generator';
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
 
   js.Node attachPosition(js.Node node, Element element) {
     // TODO(sra): Attaching positions might be cleaner if the source position
     // was on a wrapping node.
     SourceFile sourceFile = sourceFileOfElement(element);
     ast.Node expression = element.implementation.parseNode(backend.compiler);
     Token beginToken;
     Token endToken;
     if (expression == null) {
       // Synthesized node. Use the enclosing element for the location.
-      beginToken = endToken = element.position();
+      beginToken = endToken = element.position;
     } else {
       beginToken = expression.getBeginToken();
       endToken = expression.getEndToken();
     }
     // TODO(podivilov): find the right sourceFile here and remove offset
     // checks below.
     var sourcePosition, endSourcePosition;
     if (beginToken.charOffset < sourceFile.length) {
       sourcePosition = new TokenSourceFileLocation(sourceFile, beginToken);
     }
     if (endToken.charOffset < sourceFile.length) {
       endSourcePosition = new TokenSourceFileLocation(sourceFile, endToken);
     }
     return node.withPosition(sourcePosition, endSourcePosition);
   }
 
   SourceFile sourceFileOfElement(Element element) {
     // TODO(johnniwinther): remove the 'element.patch' hack.
     FunctionElement functionElement = element.asFunctionElement();
     if (functionElement != null && functionElement.patch != null) {
       element = functionElement.patch;
     }
-    return element.getCompilationUnit().script.file;
+    return element.compilationUnit.script.file;
   }
 
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
     return attachPosition(new js.Fun(parameters, body), element);
   }
 
   js.Expression generateCode(CodegenWorkItem work, HGraph graph) {
-    if (work.element.isField()) {
+    if (work.element.isField) {
       return generateLazyInitializer(work, graph);
     } else {
       return generateMethod(work, graph);
     }
   }
 
   js.Expression generateLazyInitializer(work, graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
@@ skipping 1412 matching lines @@
       if (target == backend.jsArrayAdd) {
         methodName = 'push';
       } else if (target == backend.jsArrayRemoveLast) {
         methodName = 'pop';
       } else if (target == backend.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
         world.registerInstantiatedClass(
             compiler.listClass, work.resolutionTree);
-      } else if (target.isNative() && target.isFunction()
+      } else if (target.isNative && target.isFunction
                  && !node.isInterceptedCall) {
         // A direct (i.e. non-interceptor) native call is the result of
         // optimization.  The optimization ensures any type checks or
         // conversions have been satisified.
-        methodName = target.fixedBackendName();
+        methodName = target.fixedBackendName;
       }
     }
 
     if (methodName == null) {
       methodName = backend.namer.invocationName(node.selector);
       registerMethodInvoke(node);
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   void visitInvokeConstructorBody(HInvokeConstructorBody node) {
     use(node.inputs[0]);
     js.Expression object = pop();
     String methodName = backend.namer.getNameOfInstanceMember(node.element);
     List<js.Expression> arguments = visitArguments(node.inputs);
     push(jsPropertyCall(object, methodName, arguments), node);
     world.registerStaticUse(node.element);
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(
         backend.namer.globalObjectFor(compiler.interceptorsLibrary));
     Selector selector = getOptimizedSelectorFor(node, node.selector);
     String methodName = backend.registerOneShotInterceptor(selector);
     push(jsPropertyCall(isolate, methodName, arguments), node);
-    if (selector.isGetter()) {
+    if (selector.isGetter) {
       registerGetter(node);
-    } else if (selector.isSetter()) {
+    } else if (selector.isSetter) {
       registerSetter(node);
     } else {
       registerMethodInvoke(node);
     }
     backend.registerUseInterceptor(world);
   }
 
   Selector getOptimizedSelectorFor(HInvokeDynamic node, Selector selector) {
     if (node.element != null) {
       // Create an artificial type mask to make sure only
       // [node.element] will be enqueued. We're not using the receiver
       // type because our optimizations might end up in a state where the
       // invoke dynamic knows more than the receiver.
-      ClassElement enclosing = node.element.getEnclosingClass();
+      ClassElement enclosing = node.element.enclosingClass;
       TypeMask receiverType = new TypeMask.nonNullExact(enclosing.declaration);
       return new TypedSelector(receiverType, selector);
     }
     // If [JSInvocationMirror._invokeOn] is enabled, and this call
     // might hit a `noSuchMethod`, we register an untyped selector.
     return selector.extendIfReachesAll(compiler);
   }
 
   void registerMethodInvoke(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     Element target = node.element;
-    if (target == null || target.isGetter()) {
+    if (target == null || target.isGetter) {
       // TODO(kasperl): If we have a typed selector for the call, we
       // may know something about the types of closures that need
       // the specific closure call method.
       Selector call = new Selector.callClosureFrom(selector);
       world.registerDynamicInvocation(call);
     }
     world.registerDynamicInvocation(selector);
   }
 
   void registerSetter(HInvokeDynamic node) {
@@ skipping 25 matching lines @@
     use(node.receiver);
     push(jsPropertyCall(pop(),
                         backend.namer.invocationName(call),
                         visitArguments(node.inputs)),
          node);
     world.registerDynamicInvocation(call);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     Element element = node.element;
-    ClassElement cls = element.getEnclosingClass();
+    ClassElement cls = element.enclosingClass;
     List<DartType> instantiatedTypes = node.instantiatedTypes;
 
     world.registerStaticUse(element);
 
     if (instantiatedTypes != null && !instantiatedTypes.isEmpty) {
       instantiatedTypes.forEach((type) {
         world.registerInstantiatedType(type, work.resolutionTree);
       });
     }
 
     push(backend.namer.elementAccess(node.element));
     push(new js.Call(pop(), visitArguments(node.inputs, start: 0)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     world.registerStaticUse(superMethod);
-    ClassElement superClass = superMethod.getEnclosingClass();
+    ClassElement superClass = superMethod.enclosingClass;
     if (superMethod.kind == ElementKind.FIELD) {
       String fieldName = backend.namer.instanceFieldPropertyName(superMethod);
       use(node.inputs[0]);
       js.PropertyAccess access =
           new js.PropertyAccess.field(pop(), fieldName);
       if (node.isSetter) {
         use(node.value);
         push(new js.Assignment(access, pop()), node);
       } else {
         push(access, node);
       }
     } else {
       Selector selector = node.selector;
       String methodName;
-      if (selector.isGetter()) {
+      if (selector.isGetter) {
         // If the selector we need to register a typed getter to the
         // [world]. The emitter needs to know if it needs to emit a
         // bound closure for a method.
         TypeMask receiverType = new TypeMask.nonNullExact(superClass);
         selector = new TypedSelector(receiverType, selector);
         // TODO(floitsch): we know the target. We shouldn't register a
         // dynamic getter.
         world.registerDynamicGetter(selector);
         world.registerGetterForSuperMethod(node.element);
         methodName = backend.namer.invocationName(selector);
@@ skipping 120 matching lines @@
   void generateConstant(Constant constant) {
     if (constant.isFunction) {
       FunctionConstant function = constant;
       world.registerStaticUse(function.element);
     }
     if (constant.isType) {
       // If the type is a web component, we need to ensure the constructors are
       // available to 'upgrade' the native object.
       TypeConstant type = constant;
       Element element = type.representedType.element;
-      if (element != null && element.isClass()) {
+      if (element != null && element.isClass) {
         backend.customElementsAnalysis.registerTypeConstant(element, world);
       }
     }
     push(backend.emitter.constantReference(constant));
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
     generateConstant(node.constant);
 
@@ skipping 231 matching lines @@
     value = attachLocation(value, argument);
     push(value, node);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     Element element = node.element;
-    if (element.isFunction()) {
+    if (element.isFunction) {
       push(backend.namer.isolateStaticClosureAccess(node.element));
     } else {
       push(backend.namer.elementAccess(node.element));
     }
     world.registerStaticUse(element);
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     world.registerStaticUse(element);
@@ skipping 582 matching lines @@
     }
   }
 
   void visitReadTypeVariable(HReadTypeVariable node) {
     TypeVariableElement element = node.dartType.element;
     Element helperElement = compiler.findHelper('convertRtiToRuntimeType');
     world.registerStaticUse(helperElement);
 
     use(node.inputs[0]);
     if (node.hasReceiver) {
-      if (backend.isInterceptorClass(element.getEnclosingClass())) {
+      if (backend.isInterceptorClass(element.enclosingClass)) {
         int index = RuntimeTypes.getTypeVariableIndex(element);
         js.Expression receiver = pop();
         js.Expression helper = backend.namer.elementAccess(helperElement);
         push(js.js(r'#(#.$builtinTypeInfo && #.$builtinTypeInfo[#])',
                 [helper, receiver, receiver, js.js.number(index)]));
       } else {
         backend.emitter.registerReadTypeVariable(element);
         push(js.js('#.#()',
                 [pop(), backend.namer.readTypeVariableName(element)]));
       }
@@ skipping 31 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = compiler.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     world.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }