fixes #209, remove tree mutation from CodeChecker

lib/src/info.dart

 // Copyright (c) 2015, 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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 library dev_compiler.src.info;
 
 import 'dart:mirrors';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart' as analyzer;
-import 'package:analyzer/src/generated/scanner.dart'
-    show Token, TokenType, SyntheticStringToken;
 import 'package:logging/logging.dart' show Level;
 
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/utils.dart' as utils;
 
 import 'report.dart' show Message;
 
 /// Represents a summary of the results collected by running the program
 /// checker.
 class CheckerResults {
@@ skipping 76 matching lines @@
   @override
   int get begin => node is AnnotatedNode
       ? (node as AnnotatedNode).firstTokenAfterCommentAndMetadata.offset
       : node.offset;
 
   @override
   int get end => node.end;
 }
 
 /// Implicitly injected expression conversion.
-// TODO(jmesserly): rename to have Expression suffix?
-abstract class Conversion extends Expression with StaticInfo {
+// TODO(jmesserly): better name for this? Coercion is taken (above).

[vsm, 2015/06/08 23:31:51]

Perhaps CoercionInfo?  Particularly now that this is on-the-side info and then
turned into an actual Coercion later.

[Jennifer Messerly, 2015/06/08 23:51:37]

Nice, +1. Done.

+abstract class Conversion extends StaticInfo {
   final TypeRules rules;
 
-  // TODO(jmesserly): should probably rename this "operand" for consistency with
-  // analyzer's unary expressions (e.g. PrefixExpression).
-  final Expression expression;
+  final Expression node;
 
-  AstNode get node => expression;
-  DartType _convertedType;
+  DartType get convertedType;
 
-  Conversion(this.rules, this.expression) {
-    this._convertedType = _getConvertedType();
-  }
+  Conversion(this.rules, this.node);
 
-  DartType get baseType => rules.getStaticType(expression);
-  DartType get convertedType => _convertedType;
-  DartType get staticType => _convertedType;
-
-  DartType _getConvertedType();
+  DartType get baseType => rules.getStaticType(node);
+  DartType get staticType => convertedType;
 
   // safe iff this cannot throw
   bool get safe => false;
 
   Level get level => safe ? Level.CONFIG : Level.INFO;
 
   String get description => '${this.runtimeType}: $baseType to $convertedType';
 
-  Token get beginToken => expression.beginToken;
-  Token get endToken => expression.endToken;
+  static const String _propertyName = 'dev_compiler.Conversion';
 
-  @override
-  void visitChildren(AstVisitor visitor) {
-    expression.accept(visitor);
+  /// Gets the static info associated with this node.
+  static Conversion get(AstNode node) => node.getProperty(_propertyName);
+
+  /// Sets the static info associated with this node.
+  static Conversion set(AstNode node, Conversion info) {
+    node.setProperty(_propertyName, info);
+    return info;
   }
-
-  // Use same precedence as MethodInvocation.
-  int get precedence => 15;
-
-  @override
-  Iterable get childEntities => new ChildEntities()..add(expression);
 }
 
 // Base class for all casts from base type to sub type.
 abstract class DownCast extends Conversion {
   Cast _cast;
 
   DownCast._internal(TypeRules rules, Expression expression, this._cast)
       : super(rules, expression) {
     assert(_cast.toType != baseType &&
         _cast.fromType == baseType &&
         (baseType.isDynamic ||
             // Call methods make the following non-redundant
             _cast.toType.isSubtypeOf(baseType) ||
             baseType.isAssignableTo(_cast.toType)));
   }
 
   Cast get cast => _cast;
 
-  DartType _getConvertedType() => _cast.toType;
+  DartType get convertedType => _cast.toType;
 
-  String get message => '$expression ($baseType) will need runtime check '
+  String get message => '$node ($baseType) will need runtime check '
       'to cast to type $convertedType';
 
   // Factory to create correct DownCast variant.
   static StaticInfo create(TypeRules rules, Expression expression, Cast cast,
       {String reason}) {
     final fromT = cast.fromType;
     final toT = cast.toType;
 
     // toT <:_R fromT => to <: fromT
     // NB: classes with call methods are subtypes of function
@@ skipping 44 matching lines @@
 
     // Assignment cast
     var parent = expression.parent;
     if (parent is VariableDeclaration && (parent.initializer == expression)) {
       return new AssignmentCast(rules, expression, cast);
     }
 
     // Other casts
     return new DownCastImplicit(rules, expression, cast);
   }
-
-  accept(AstVisitor visitor) {
-    if (visitor is ConversionVisitor) {
-      return visitor.visitDownCast(this);
-    } else {
-      return expression.accept(visitor);
-    }
-  }
 }
 
 //
 // Standard down casts.  These casts are implicitly injected by the compiler.
 //
 
 // A down cast from dynamic to T.
 class DynamicCast extends DownCast {
   DynamicCast(TypeRules rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
@@ skipping 47 matching lines @@
 class DownCastImplicit extends DownCast {
   DownCastImplicit(TypeRules rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   final Level level = Level.WARNING;
 }
 
 // An inferred type for the wrapped expression, which may need to be
 // reified into the term
 abstract class InferredTypeBase extends Conversion {
-  DartType _type;
+  final DartType _type;
 
   InferredTypeBase._internal(TypeRules rules, Expression expression, this._type)
       : super(rules, expression);
 
   DartType get type => _type;
-
-  DartType _getConvertedType() => type;
-
-  String get message => '$expression has inferred type $type';
-
+  DartType get convertedType => type;
+  String get message => '$node has inferred type $type';
   Level get level => Level.INFO;
-
-  accept(AstVisitor visitor) {
-    if (visitor is ConversionVisitor) {
-      return visitor.visitInferredTypeBase(this);
-    } else {
-      return expression.accept(visitor);
-    }
-  }
 }
 
 // Standard / unspecialized inferred type
 class InferredType extends InferredTypeBase {
   InferredType(TypeRules rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
   // Factory to create correct InferredType variant.
   static InferredTypeBase create(
       TypeRules rules, Expression expression, DartType type) {
@@ skipping 27 matching lines @@
 // An inferred type for a closure expression
 class InferredTypeClosure extends InferredTypeBase {
   InferredTypeClosure(TypeRules rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 }
 
 class DynamicInvoke extends Conversion {
   DynamicInvoke(TypeRules rules, Expression expression)
       : super(rules, expression);
 
-  DartType _getConvertedType() => rules.provider.dynamicType;
-
-  String get message => '$expression requires dynamic invoke';
+  DartType get convertedType => rules.provider.dynamicType;
+  String get message => '$node requires dynamic invoke';
   Level get level => Level.INFO;
-
-  accept(AstVisitor visitor) {
-    if (visitor is ConversionVisitor) {
-      return visitor.visitDynamicInvoke(this);
-    } else {
-      return expression.accept(visitor);
-    }
-  }
 }
 
 abstract class StaticError extends StaticInfo {
   final AstNode node;
 
   StaticError(this.node);
 
   Level get level => Level.SEVERE;
 }
 
@@ skipping 147 matching lines @@
 /// <http://goo.gl/q1T4BB>
 ///
 /// For now this is the only pattern we support.
 class InvalidSuperInvocation extends StaticError {
   InvalidSuperInvocation(SuperConstructorInvocation node) : super(node);
 
   String get message => "super call must be last in an initializer list "
       "(see http://goo.gl/q1T4BB): $node";
 }
 
-/// A simple generalizing visitor interface for the conversion nodes.
-/// This can be mixed in to your visitor if the AST can contain these nodes.
-abstract class ConversionVisitor<R> implements AstVisitor<R> {
-  /// This method must be implemented. It is typically supplied by the base
-  /// GeneralizingAstVisitor<R>.
-  R visitNode(AstNode node);
-
-  /// The catch-all for any kind of conversion
-  R visitConversion(Conversion node) => visitNode(node);
-
-  // Methods for conversion subtypes:
-  R visitDownCast(DownCast node) => visitConversion(node);
-  R visitDynamicInvoke(DynamicInvoke node) => visitConversion(node);
-  R visitInferredTypeBase(InferredTypeBase node) => visitConversion(node);
-}
-
 /// Automatically infer list of types by scanning this library using mirrors.
 final List<Type> infoTypes = () {
   var allTypes = new Set();
   var baseTypes = new Set();
   var infoMirror = reflectClass(StaticInfo);
   var libMirror = infoMirror.owner as LibraryMirror;
   var declarations = libMirror.declarations.values;
   for (ClassMirror cls in declarations.where((d) => d is ClassMirror)) {
     if (cls.isSubtypeOf(infoMirror)) {
       allTypes.add(cls);
@@ skipping 11 matching lines @@
     var isError = severity == analyzer.ErrorSeverity.WARNING;
     var level = isError ? Level.SEVERE : Level.WARNING;
     int begin = error.offset;
     int end = begin + error.length;
     return new AnalyzerError(error.message, level, begin, end);
   }
 
   const AnalyzerError(String message, Level level, int begin, int end)
       : super(message, level, begin, end);
 }