/*
 * Copyright 2010 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 * 
 * 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.gwt.dev.jjs.impl;

import com.google.gwt.dev.jjs.SourceInfo;
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JBinaryOperation;
import com.google.gwt.dev.jjs.ast.JBinaryOperator;
import com.google.gwt.dev.jjs.ast.JConditional;
import com.google.gwt.dev.jjs.ast.JDeclarationStatement;
import com.google.gwt.dev.jjs.ast.JExpression;
import com.google.gwt.dev.jjs.ast.JField;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JMethodCall;
import com.google.gwt.dev.jjs.ast.JNewArray;
import com.google.gwt.dev.jjs.ast.JParameter;
import com.google.gwt.dev.jjs.ast.JPrimitiveType;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JReferenceType;
import com.google.gwt.dev.jjs.ast.JReturnStatement;
import com.google.gwt.dev.jjs.ast.JThrowStatement;
import com.google.gwt.dev.jjs.ast.JType;
import com.google.gwt.dev.jjs.ast.JVisitor;
import com.google.gwt.dev.jjs.ast.js.JsniMethodRef;

import java.util.List;

/**
 * This class will identify instances of an implicit upcast between
 * non-primitive types, and call the overridable processImplicitUpcast method.
 * 
 * TODO(jbrosenberg): Consider extending to handle implicit upcasts between
 * primitive types. This is not as straightforward as for reference types,
 * because primitives can be boxed and unboxed implicitly as well.
 */
public class ImplicitUpcastAnalyzer extends JVisitor {

  protected JMethod currentMethod;
  private final JType javaScriptObjectType;
  private final JType nullType;
  private final JType throwableType;

  public ImplicitUpcastAnalyzer(JProgram program) {
    this.throwableType = program.getIndexedType("Throwable");
    this.javaScriptObjectType = program.getJavaScriptObject();
    this.nullType = program.getTypeNull();
  }

  @Override
  public void endVisit(JBinaryOperation x, Context ctx) {
    if (x.isAssignment()) {
      processIfTypesNotEqual(x.getRhs().getType(), x.getLhs().getType(), x.getSourceInfo());
    } else if (x.getRhs().getType() == nullType) {
      processIfTypesNotEqual(nullType, x.getLhs().getType(), x.getSourceInfo());
    } else if (x.getLhs().getType() == nullType) {
      processIfTypesNotEqual(nullType, x.getRhs().getType(), x.getSourceInfo());
    } else if (x.getOp() == JBinaryOperator.CONCAT || x.getOp() == JBinaryOperator.EQ
        || x.getOp() == JBinaryOperator.NEQ) {
      /*
       * Since we are not attempting to handle detection of upcasts between
       * primitive types, we limit handling here to CONCAT, EQ and NEQ. Need to
       * do both directions.
       */
      processIfTypesNotEqual(x.getLhs().getType(), x.getRhs().getType(), x.getSourceInfo());
      processIfTypesNotEqual(x.getRhs().getType(), x.getLhs().getType(), x.getSourceInfo());
    }
  }

  @Override
  public void endVisit(JConditional x, Context ctx) {
    processIfTypesNotEqual(x.getThenExpr().getType(), x.getType(), x.getSourceInfo());
    processIfTypesNotEqual(x.getElseExpr().getType(), x.getType(), x.getSourceInfo());
  }

  @Override
  public void endVisit(JDeclarationStatement x, Context ctx) {
    if (x.getInitializer() != null) {
      processIfTypesNotEqual(x.getInitializer().getType(), x.getVariableRef().getType(), x
          .getSourceInfo());
    }
  }

  @Override
  public void endVisit(JField x, Context ctx) {
    if (x.getInitializer() == null && !x.isFinal()) {
      if (!(x.getType() instanceof JPrimitiveType)) {
        // if it is declared without an initial value, it defaults to null
        processIfTypesNotEqual(nullType, x.getType(), x.getSourceInfo());
      }
    }
  }

  @Override
  public void endVisit(JMethod x, Context ctx) {
    // check for upcast in return type as compared to an overridden method
    List<JMethod> overrides = x.getOverrides();
    if (overrides != null && overrides.size() > 0) {
      // only check the first one, since other ones will be checked when those
      // overridden methods are visited, don't want to do redundant work
      processIfTypesNotEqual(x.getType(), overrides.get(0).getType(), x.getSourceInfo());
    }

    if (x.getBody() != null && x.getBody().isNative()) {
      /*
       * Check if this method has a native (jsni) method body, in which case all
       * arguments passed in are implicitly cast to JavaScriptObject
       */
      List<JParameter> params = x.getParams();
      for (int i = 0; i < params.size(); i++) {
        processIfTypesNotEqual(params.get(i).getType(), javaScriptObjectType, x.getSourceInfo());
      }

      /*
       * Check if this method has a non-void return type, in which case it will
       * be implicitly cast from JavaScriptObject
       */
      if (x.getType() != JPrimitiveType.VOID) {
        processIfTypesNotEqual(javaScriptObjectType, x.getType(), x.getSourceInfo());
      }
    }
  }

  @Override
  public void endVisit(JMethodCall x, Context ctx) {
    // check for upcast in argument passing
    List<JExpression> args = x.getArgs();
    List<JParameter> params = x.getTarget().getParams();

    for (int i = 0; i < args.size(); i++) {
      // make sure the param wasn't pruned
      if (i < params.size()) {
        processIfTypesNotEqual(args.get(i).getType(), params.get(i).getType(), x.getSourceInfo());
      }
    }
  }

  @Override
  public void endVisit(JNewArray x, Context ctx) {
    JType elementType = x.getArrayType().getElementType();
    if (x.initializers != null) {
      for (JExpression init : x.initializers) {
        processIfTypesNotEqual(init.getType(), elementType, x.getSourceInfo());
      }
    }
  }

  @Override
  public void endVisit(JReturnStatement x, Context ctx) {
    if (x.getExpr() != null) {
      // check against the current method return type
      processIfTypesNotEqual(x.getExpr().getType(), currentMethod.getType(), x.getSourceInfo());
    }
  }

  @Override
  public void endVisit(JsniMethodRef x, Context ctx) {
    // the return type of this method ref will be cast to JavaScriptObject
    if (x.getTarget().getType() != JPrimitiveType.VOID) {
      processIfTypesNotEqual(x.getTarget().getType(), javaScriptObjectType, x.getSourceInfo());
    }

    // check referenced method's params, which are passed as JavaScriptObjects
    List<JParameter> params = x.getTarget().getParams();
    for (int i = 0; i < params.size(); i++) {
      processIfTypesNotEqual(javaScriptObjectType, params.get(i).getType(), x.getSourceInfo());
    }
  }

  @Override
  public void endVisit(JThrowStatement x, Context ctx) {
    // all things thrown are upcast to a Throwable
    JType type = x.getExpr().getType();
    if (type instanceof JReferenceType) {
      type = ((JReferenceType) type).getUnderlyingType();
    }
    processIfTypesNotEqual(type, throwableType, x.getSourceInfo());
  }

  @Override
  public boolean visit(JMethod x, Context ctx) {
    // save this, so can use it later for checking JReturnStatement
    currentMethod = x;
    return true;
  }

  /**
   * An overriding method will be called for each detected implicit upcast.
   * 
   * @param fromType
   * @param destType
   */
  protected void processImplicitUpcast(JType fromType, JType destType, SourceInfo info) {
    // override
  }

  private void processIfTypesNotEqual(JType fromType, JType destType, SourceInfo info) {
    if (fromType != destType) {
      processImplicitUpcast(fromType, destType, info);
    }
  }
}