dart/editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/internal/resolver/StaticTypeVerifier.java

/*
 * Copyright (c) 2012, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.dart.engine.internal.resolver;

import com.google.dart.engine.ast.AstNode;
import com.google.dart.engine.ast.BreakStatement;
import com.google.dart.engine.ast.CommentReference;
import com.google.dart.engine.ast.CompilationUnit;
import com.google.dart.engine.ast.ConstructorFieldInitializer;
import com.google.dart.engine.ast.ConstructorName;
import com.google.dart.engine.ast.ContinueStatement;
import com.google.dart.engine.ast.ExportDirective;
import com.google.dart.engine.ast.Expression;
import com.google.dart.engine.ast.ImportDirective;
import com.google.dart.engine.ast.Label;
import com.google.dart.engine.ast.LibraryIdentifier;
import com.google.dart.engine.ast.MethodInvocation;
import com.google.dart.engine.ast.PrefixedIdentifier;
import com.google.dart.engine.ast.RedirectingConstructorInvocation;
import com.google.dart.engine.ast.SimpleIdentifier;
import com.google.dart.engine.ast.SuperConstructorInvocation;
import com.google.dart.engine.ast.TypeName;
import com.google.dart.engine.ast.visitor.GeneralizingAstVisitor;
import com.google.dart.engine.element.PrefixElement;
import com.google.dart.engine.internal.type.DynamicTypeImpl;
import com.google.dart.engine.type.Type;
import com.google.dart.engine.utilities.io.PrintStringWriter;

import junit.framework.Assert;

import java.util.ArrayList;

/**
 * Instances of the class {@code StaticTypeVerifier} verify that all of the nodes in an AST
 * structure that should have a static type associated with them do have a static type.
 */
public class StaticTypeVerifier extends GeneralizingAstVisitor<Void> {
  /**
   * A list containing all of the AST Expression nodes that were not resolved.
   */
  private ArrayList<Expression> unresolvedExpressions = new ArrayList<Expression>();

  /**
   * A list containing all of the AST Expression nodes for which a propagated type was computed but
   * where that type was not more specific than the static type.
   */
  private ArrayList<Expression> invalidlyPropagatedExpressions = new ArrayList<Expression>();

  /**
   * A list containing all of the AST TypeName nodes that were not resolved.
   */
  private ArrayList<TypeName> unresolvedTypes = new ArrayList<TypeName>();

  /**
   * Counter for the number of Expression nodes visited that are resolved.
   */
  int resolvedExpressionCount = 0;

  /**
   * Counter for the number of Expression nodes visited that have propagated type information.
   */
  int propagatedExpressionCount = 0;

  /**
   * Counter for the number of TypeName nodes visited that are resolved.
   */
  int resolvedTypeCount = 0;

  /**
   * Initialize a newly created verifier to verify that all of the nodes in an AST structure that
   * should have a static type associated with them do have a static type.
   */
  public StaticTypeVerifier() {
    super();
  }

  /**
   * Assert that all of the visited nodes have a static type associated with them.
   */
  public void assertResolved() {
    if (!unresolvedExpressions.isEmpty() /*|| !invalidlyPropagatedExpressions.isEmpty()*/
        || !unresolvedTypes.isEmpty()) {
      @SuppressWarnings("resource")
      PrintStringWriter writer = new PrintStringWriter();
      int unresolvedTypeCount = unresolvedTypes.size();
      if (unresolvedTypeCount > 0) {
        writer.print("Failed to resolve ");
        writer.print(unresolvedTypeCount);
        writer.print(" of ");
        writer.print(resolvedTypeCount + unresolvedTypeCount);
        writer.println(" type names:");
        for (TypeName identifier : unresolvedTypes) {
          writer.print("  ");
          writer.print(identifier.toString());
          writer.print(" (");
          writer.print(getFileName(identifier));
          writer.print(" : ");
          writer.print(identifier.getOffset());
          writer.println(")");
        }
      }
      int unresolvedExpressionCount = unresolvedExpressions.size();
      if (unresolvedExpressionCount > 0) {
        writer.println("Failed to resolve ");
        writer.print(unresolvedExpressionCount);
        writer.print(" of ");
        writer.print(resolvedExpressionCount + unresolvedExpressionCount);
        writer.println(" expressions:");
        for (Expression expression : unresolvedExpressions) {
          writer.print("  ");
          writer.print(expression.toString());
          writer.print(" (");
          writer.print(getFileName(expression));
          writer.print(" : ");
          writer.print(expression.getOffset());
          writer.println(")");
        }
      }
      int invalidlyPropagatedExpressionCount = invalidlyPropagatedExpressions.size();
      if (invalidlyPropagatedExpressionCount > 0) {
        writer.println("Incorrectly propagated ");
        writer.print(invalidlyPropagatedExpressionCount);
        writer.print(" of ");
        writer.print(propagatedExpressionCount);
        writer.println(" expressions:");
        for (Expression expression : invalidlyPropagatedExpressions) {
          writer.print("  ");
          writer.print(expression.toString());
          writer.print(" [");
          writer.print(expression.getStaticType().getDisplayName());
          writer.print(", ");
          writer.print(expression.getPropagatedType().getDisplayName());
          writer.println("]");
          writer.print("    ");
          writer.print(getFileName(expression));
          writer.print(" : ");
          writer.print(expression.getOffset());
          writer.println(")");
        }
      }
      Assert.fail(writer.toString());
    }
  }

  @Override
  public Void visitBreakStatement(BreakStatement node) {
    // Don't visit the children because the identifier (if it exists) is not expected to have a type.
    return null;
  }

  @Override
  public Void visitCommentReference(CommentReference node) {
    // Do nothing.
    return null;
  }

  @Override
  public Void visitContinueStatement(ContinueStatement node) {
    // Don't visit the children because the identifier (if it exists) is not expected to have a type.
    return null;
  }

  @Override
  public Void visitExportDirective(ExportDirective node) {
    // Don't visit the children because they are not expected to have a type.
    return null;
  }

  @Override
  public Void visitExpression(Expression node) {
    node.visitChildren(this);
    Type staticType = node.getStaticType();
    if (staticType == null) {
      unresolvedExpressions.add(node);
    } else {
      resolvedExpressionCount++;
      Type propagatedType = node.getPropagatedType();
      if (propagatedType != null) {
        propagatedExpressionCount++;
        if (!propagatedType.isMoreSpecificThan(staticType)) {
          invalidlyPropagatedExpressions.add(node);
        }
      }
    }
    return null;
  }

  @Override
  public Void visitImportDirective(ImportDirective node) {
    // Don't visit the children because they are not expected to have a type.
    return null;
  }

  @Override
  public Void visitLabel(Label node) {
    // Don't visit the children because the identifier is not expected to have a type.
    return null;
  }

  @Override
  public Void visitLibraryIdentifier(LibraryIdentifier node) {
    // Do nothing, LibraryIdentifiers and children don't have an associated static type.
    return null;
  }

  @Override
  public Void visitPrefixedIdentifier(PrefixedIdentifier node) {
    // In cases where we have a prefixed identifier where the prefix is dynamic, we don't want to
    // assert that the node will have a type.
    if (node.getStaticType() == null
        && node.getPrefix().getStaticType() == DynamicTypeImpl.getInstance()) {
      return null;
    }
    return super.visitPrefixedIdentifier(node);
  }

  @Override
  public Void visitSimpleIdentifier(SimpleIdentifier node) {
    // In cases where identifiers are being used for something other than an expressions,
    // then they can be ignored.
    AstNode parent = node.getParent();
    if (parent instanceof MethodInvocation && node == ((MethodInvocation) parent).getMethodName()) {
      return null;
    } else if (parent instanceof RedirectingConstructorInvocation
        && node == ((RedirectingConstructorInvocation) parent).getConstructorName()) {
      return null;
    } else if (parent instanceof SuperConstructorInvocation
        && node == ((SuperConstructorInvocation) parent).getConstructorName()) {
      return null;
    } else if (parent instanceof ConstructorName && node == ((ConstructorName) parent).getName()) {
      return null;
    } else if (parent instanceof ConstructorFieldInitializer
        && node == ((ConstructorFieldInitializer) parent).getFieldName()) {
      return null;
    } else if (node.getStaticElement() instanceof PrefixElement) {
      // Prefixes don't have a type.
      return null;
    }
    return super.visitSimpleIdentifier(node);
  }

  @Override
  public Void visitTypeName(TypeName node) {
    // Note: do not visit children from this node, the child SimpleIdentifier in TypeName
    // (i.e. "String") does not have a static type defined.
    if (node.getType() == null) {
      unresolvedTypes.add(node);
    } else {
      resolvedTypeCount++;
    }
    return null;
  }

  private String getFileName(AstNode node) {
    // TODO (jwren) there are two copies of this method, one here and one in ResolutionVerifier,
    // they should be resolved into a single method
    if (node != null) {
      AstNode root = node.getRoot();
      if (root instanceof CompilationUnit) {
        CompilationUnit rootCU = ((CompilationUnit) root);
        if (rootCU.getElement() != null) {
          return rootCU.getElement().getSource().getFullName();
        } else {
          return "<unknown file- CompilationUnit.getElement() returned null>";
        }
      } else {
        return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
      }
    }
    return "<unknown file- ASTNode is null>";
  }
}