Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/compiler.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 dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 243 matching lines @@
   ClassElement get boolImplementation => compiler.boolClass;
   ClassElement get nullImplementation => compiler.nullClass;
   ClassElement get uint32Implementation => compiler.intClass;
   ClassElement get uint31Implementation => compiler.intClass;
   ClassElement get positiveIntImplementation => compiler.intClass;
 
   ClassElement defaultSuperclass(ClassElement element) => compiler.objectClass;
 
   bool isDefaultNoSuchMethodImplementation(Element element) {
     assert(element.name == Compiler.NO_SUCH_METHOD);
-    ClassElement classElement = element.getEnclosingClass();
+    ClassElement classElement = element.enclosingClass;
     return classElement == compiler.objectClass;
   }
 
   bool isInterceptorClass(ClassElement element) => false;
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
   Future onLibraryLoaded(LibraryElement library, Uri uri) {
     return new Future.value();
   }
@@ skipping 490 matching lines @@
       return node;
     } else if (node is Node) {
       return spanFromNode(node);
     } else if (node is Token) {
       return spanFromTokens(node, node);
     } else if (node is HInstruction) {
       return spanFromHInstruction(node);
     } else if (node is Element) {
       return spanFromElement(node);
     } else if (node is MetadataAnnotation) {
-      Uri uri = node.annotatedElement.getCompilationUnit().script.readableUri;
+      Uri uri = node.annotatedElement.compilationUnit.script.readableUri;
       return spanFromTokens(node.beginToken, node.endToken, uri);
     } else {
       throw 'No error location.';
     }
   }
 
   /// Finds the approximate [Element] for [node]. [currentElement] is used as
   /// the default value.
   Element elementFromSpannable(Spannable node) {
     Element element;
@@ skipping 179 matching lines @@
     dynamicClass.ensureResolved(this);
 
     proxyConstant =
         resolver.constantCompiler.compileConstant(coreLibrary.find('proxy'));
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
     Selector callConstructor = new Selector.callConstructor(
-        "", listClass.getLibrary());
+        "", listClass.library);
     return _unnamedListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
 
   Element _filledListConstructor;
   Element get filledListConstructor {
     if (_filledListConstructor != null) return _filledListConstructor;
     Selector callConstructor = new Selector.callConstructor(
-        "filled", listClass.getLibrary());
+        "filled", listClass.library);
     return _filledListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
 
   Future scanBuiltinLibraries() {
     return scanBuiltinLibrary('_js_helper').then((LibraryElement library) {
       jsHelperLibrary = library;
       return scanBuiltinLibrary('_interceptors');
     }).then((LibraryElement library) {
       interceptorsLibrary = library;
@@ skipping 78 matching lines @@
               MessageKind.GENERIC,
               {'text': "Could not find '$MAIN'."});
         } else if (!analyzeAll) {
           reportFatalError(mainApp, MessageKind.GENERIC,
               {'text': "Could not find '$MAIN'. "
                        "No source will be analyzed. "
                        "Use '--analyze-all' to analyze all code in the "
                        "library."});
         }
       } else {
-        if (main.isErroneous()) {
+        if (main.isErroneous) {
           reportFatalError(main, MessageKind.GENERIC,
               {'text': "Cannot determine which '$MAIN' to use."});
-        } else if (!main.isFunction()) {
+        } else if (!main.isFunction) {
           reportFatalError(main, MessageKind.GENERIC,
               {'text': "'$MAIN' is not a function."});
         }
         mainFunction = main;
         FunctionSignature parameters = mainFunction.computeSignature(this);
         if (parameters.parameterCount > 2) {
           int index = 0;
           parameters.forEachParameter((Element parameter) {
             if (index++ < 2) return;
             reportError(parameter, MessageKind.GENERIC,
@@ skipping 105 matching lines @@
   }
 
   void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
     void enqueueAll(Element element) {
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
-    if (element.isClass()) {
+    if (element.isClass) {
       ClassElement cls = element;
       cls.ensureResolved(this);
       cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
       world.registerInstantiatedClass(element, globalDependencies);
     } else {
       world.addToWorkList(element);
     }
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
@@ skipping 10 matching lines @@
   }
 
   void processQueue(Enqueuer world, Element main) {
     world.nativeEnqueuer.processNativeClasses(libraries.values);
     if (main != null) {
       FunctionElement mainMethod = main;
       if (mainMethod.computeSignature(this).parameterCount != 0) {
         // TODO(ngeoffray, floitsch): we should also ensure that the
         // class IsolateMessage is instantiated. Currently, just enabling
         // isolate support works.
-        world.enableIsolateSupport(main.getLibrary());
+        world.enableIsolateSupport(main.library);
         world.registerInstantiatedClass(listClass, globalDependencies);
         world.registerInstantiatedClass(stringClass, globalDependencies);
       }
       world.addToWorkList(main);
     }
     progress.reset();
     world.forEach((WorkItem work) {
       withCurrentElement(work.element, () => work.run(this, world));
     });
     world.queueIsClosed = true;
@@ skipping 12 matching lines @@
       world.forEach((WorkItem work) {
         internalError(work.element, "Work list is not empty.");
       });
     }
     if (!REPORT_EXCESS_RESOLUTION) return;
     var resolved = new Set.from(enqueuer.resolution.resolvedElements.keys);
     for (Element e in enqueuer.codegen.generatedCode.keys) {
       resolved.remove(e);
     }
     for (Element e in new Set.from(resolved)) {
-      if (e.isClass() ||
-          e.isField() ||
-          e.isTypeVariable() ||
-          e.isTypedef() ||
+      if (e.isClass ||
+          e.isField ||
+          e.isTypeVariable ||
+          e.isTypedef ||
           identical(e.kind, ElementKind.ABSTRACT_FIELD)) {
         resolved.remove(e);
       }
       if (identical(e.kind, ElementKind.GENERATIVE_CONSTRUCTOR)) {
-        ClassElement enclosingClass = e.getEnclosingClass();
+        ClassElement enclosingClass = e.enclosingClass;
         resolved.remove(e);
 
       }
-      if (identical(e.getLibrary(), jsHelperLibrary)) {
+      if (identical(e.library, jsHelperLibrary)) {
         resolved.remove(e);
       }
-      if (identical(e.getLibrary(), interceptorsLibrary)) {
+      if (identical(e.library, interceptorsLibrary)) {
         resolved.remove(e);
       }
     }
     log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reportWarning(e,
           MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
   TreeElements analyzeElement(Element element) {
     assert(invariant(element,
-           element.impliesType() ||
-           element.isField() ||
-           element.isFunction() ||
-           element.isGenerativeConstructor() ||
-           element.isGetter() ||
-           element.isSetter(),
+           element.impliesType ||
+           element.isField ||
+           element.isFunction ||
+           element.isGenerativeConstructor ||
+           element.isGetter ||
+           element.isSetter,
            message: 'Unexpected element kind: ${element.kind}'));
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     assert(invariant(element, element.isDeclaration));
     ResolutionEnqueuer world = enqueuer.resolution;
     TreeElements elements = world.getCachedElements(element);
     if (elements != null) return elements;
     assert(parser != null);
     Node tree = parser.parse(element);
     assert(invariant(element, !element.isSynthesized || tree == null));
@@ skipping 132 matching lines @@
   }
 
   SourceSpan spanFromTokens(Token begin, Token end, [Uri uri]) {
     if (begin == null || end == null) {
       // TODO(ahe): We can almost always do better. Often it is only
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
     if (uri == null && currentElement != null) {
-      uri = currentElement.getCompilationUnit().script.readableUri;
+      uri = currentElement.compilationUnit.script.readableUri;
     }
     return SourceSpan.withCharacterOffsets(begin, end,
       (beginOffset, endOffset) => new SourceSpan(uri, beginOffset, endOffset));
   }
 
   SourceSpan spanFromNode(Node node) {
     return spanFromTokens(node.getBeginToken(), node.getEndToken());
   }
 
   SourceSpan spanFromElement(Element element) {
     if (Elements.isErroneousElement(element)) {
       element = element.enclosingElement;
     }
-    if (element.position() == null &&
-        !element.isLibrary() &&
-        !element.isCompilationUnit()) {
+    if (element.position == null &&
+        !element.isLibrary &&
+        !element.isCompilationUnit) {
       // Sometimes, the backend fakes up elements that have no
       // position. So we use the enclosing element instead. It is
       // not a good error location, but cancel really is "internal
       // error" or "not implemented yet", so the vicinity is good
       // enough for now.
       element = element.enclosingElement;
       // TODO(ahe): I plan to overhaul this infrastructure anyways.
     }
     if (element == null) {
       element = currentElement;
     }
-    Token position = element.position();
-    Uri uri = element.getCompilationUnit().script.readableUri;
+    Token position = element.position;
+    Uri uri = element.compilationUnit.script.readableUri;
     return (position == null)
         ? new SourceSpan(uri, 0, 0)
         : spanFromTokens(position, position, uri);
   }
 
   SourceSpan spanFromHInstruction(HInstruction instruction) {
     Element element = instruction.sourceElement;
     if (element == null) element = currentElement;
     var position = instruction.sourcePosition;
     if (position == null) return spanFromElement(element);
     Token token = position.token;
     if (token == null) return spanFromElement(element);
-    Uri uri = element.getCompilationUnit().script.readableUri;
+    Uri uri = element.compilationUnit.script.readableUri;
     return spanFromTokens(token, token, uri);
   }
 
   /**
    * Translates the [resolvedUri] into a readable URI.
    *
    * The [importingLibrary] holds the library importing [resolvedUri] or
    * [:null:] if [resolvedUri] is loaded as the main library. The
    * [importingLibrary] is used to grant access to internal libraries from
    * platform libraries and patch libraries.
@@ skipping 53 matching lines @@
         }
       }
       prevToken = currentToken;
       currentToken = currentToken.next;
     }
     return firstToken;
   }
 
   void reportUnusedCode() {
     void checkLive(member) {
-      if (member.isFunction()) {
+      if (member.isFunction) {
         if (!enqueuer.resolution.isLive(member)) {
           reportHint(member, MessageKind.UNUSED_METHOD,
                      {'name': member.name});
         }
-      } else if (member.isClass()) {
+      } else if (member.isClass) {
         if (!member.isResolved) {
           reportHint(member, MessageKind.UNUSED_CLASS,
                      {'name': member.name});
         } else {
           member.forEachLocalMember(checkLive);
         }
-      } else if (member.isTypedef()) {
+      } else if (member.isTypedef) {
         if (!member.isResolved) {
           reportHint(member, MessageKind.UNUSED_TYPEDEF,
                      {'name': member.name});
         }
       }
     }
     libraries.forEach((_, library) {
       // TODO(ahe): Implement better heuristics to discover entry points of
       // packages and use that to discover unused implementation details in
       // packages.
@@ skipping 35 matching lines @@
       entrypoints.add(mainApp.canonicalUri);
     }
     if (librariesToAnalyzeWhenRun != null) {
       entrypoints.addAll(librariesToAnalyzeWhenRun);
     }
     if (entrypoints.isEmpty && assumeInUserCode) {
       // Assume in user code since [mainApp] has not been set yet.
       return true;
     }
     if (element == null) return false;
-    Uri libraryUri = element.getLibrary().canonicalUri;
+    Uri libraryUri = element.library.canonicalUri;
     if (libraryUri.scheme == 'package') {
       for (Uri uri in entrypoints) {
         if (uri.scheme != 'package') continue;
         int slashPos = libraryUri.path.indexOf('/');
         if (slashPos != -1) {
           String packageName = libraryUri.path.substring(0, slashPos + 1);
           if (uri.path.startsWith(packageName)) {
             return true;
           }
         } else {
@@ skipping 10 matching lines @@
     return false;
   }
 
   /// Return a canonical URI for the source of [element].
   ///
   /// For a package library with canonical URI 'package:foo/bar/baz.dart' the
   /// return URI is 'package:foo'. For non-package libraries the returned URI is
   /// the canonical URI of the library itself.
   Uri getCanonicalUri(Element element) {
     if (element == null) return null;
-    Uri libraryUri = element.getLibrary().canonicalUri;
+    Uri libraryUri = element.library.canonicalUri;
     if (libraryUri.scheme == 'package') {
       int slashPos = libraryUri.path.indexOf('/');
       if (slashPos != -1) {
         String packageName = libraryUri.path.substring(0, slashPos);
         return new Uri(scheme: 'package', path: packageName);
       }
     }
     return libraryUri;
   }
 
@@ skipping 117 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }