user/src/com/google/gwt/uibinder/rebind/FieldReference.java

/*
 * Copyright 2009 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.uibinder.rebind;

import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;

import java.util.Arrays;
import java.util.LinkedHashSet;

/**
 * Represents a <code>{field.reference}</code>. Collects all the types a
 * particular reference has been asked to return, and can validate that it
 * actually does so.
 */
public class FieldReference {
  private static class LeftHand {
    /**
     * The type of values acceptible to this LHS, in order of preference
     */
    private final JType[] types;
    /**
     * The element on the LHS, for error reporting
     */
    private final XMLElement source;

    LeftHand(XMLElement source, JType... types) {
      this.types = Arrays.copyOf(types, types.length);
      this.source = source;
    }
  }

  public static String renderTypesList(JType[] types) {
    StringBuilder b = new StringBuilder();
    for (int i = 0; i < types.length; i++) {
      if (i > 0 && i == types.length - 1) {
        b.append(" or ");
      } else if (i > 0) {
        b.append(", ");
      }
      b.append(types[i].getQualifiedSourceName());
    }

    return b.toString();
  }

  private final FieldManager fieldManager;
  private final XMLElement source;
  private final String debugString;
  private final String[] elements;

  private final LinkedHashSet<LeftHand> leftHandTypes = new LinkedHashSet<LeftHand>();

  private final TypeOracle typeOracle;

  FieldReference(String reference, XMLElement source, FieldManager fieldManager,
      TypeOracle typeOracle) {
    this.source = source;
    this.debugString = "{" + reference + "}";
    this.fieldManager = fieldManager;
    this.typeOracle = typeOracle;
    elements = reference.split("\\.");
  }

  public void addLeftHandType(XMLElement source, JType... types) {
    leftHandTypes.add(new LeftHand(source, types));
  }

  public String getFieldName() {
    return elements[0];
  }

  public JType getReturnType() {
    return getReturnType(null);
  }

  /**
   * Returns the type returned by this field ref.
   * 
   * @param logger optional logger to report errors on, may be null
   * @return the field ref, or null
   */
  public JType getReturnType(MonitoredLogger logger) {
    FieldWriter field = fieldManager.lookup(elements[0]);
    if (field == null) {
      if (logger != null) {
        /*
         * It's null when called from HtmlTemplateMethodWriter, which fires
         * after validation has already succeeded.
         */
        logger.error(source, "in %s, no field named %s", this, elements[0]);
      }
      return null;
    }

    return field.getReturnType(elements, logger);
  }

  public XMLElement getSource() {
    return source;
  }

  @Override
  public String toString() {
    return debugString;
  }

  public void validate(MonitoredLogger logger) {
    JType myReturnType = getReturnType(logger);
    if (myReturnType == null) {
      return;
    }

    for (LeftHand left : leftHandTypes) {
      ensureAssignable(left, myReturnType, logger);
    }
  }

  /**
   * Returns a failure message if the types don't mesh, or null on success.
   */
  private void ensureAssignable(LeftHand left, JType rightHandType, MonitoredLogger logger) {
    assert left.types.length > 0;

    for (JType leftType : left.types) {

      if (leftType == rightHandType) {
        return;
      }

      if (matchingNumberTypes(leftType, rightHandType)) {
        return;
      }

      boolean[] explicitFailure = {false};
      if (handleMismatchedNonNumericPrimitives(leftType, rightHandType, explicitFailure)) {
        if (explicitFailure[0]) {
          continue;
        }
      }

      JClassType leftClass = leftType.isClassOrInterface();
      if (leftClass != null) {
        JClassType rightClass = rightHandType.isClassOrInterface();
        if ((rightClass == null) || !leftClass.isAssignableFrom(rightClass)) {
          continue;
        }
      }

      /*
       * If we have reached the bottom of the loop, we don't see a problem with
       * assigning to this left hand type. Return without logging any error.
       * This is pretty conservative -- we have a white list of bad conditions,
       * not an exhaustive check of valid assignments. We're not confident that
       * we know every error case, and are more worried about being artificially
       * restrictive.
       */
      return;
    }

    /*
     * Every possible left hand type had some kind of failure. Log this sad
     * fact, which will halt processing.
     */
    logger.error(left.source, "%s required, but %s returns %s", renderTypesList(left.types),
        FieldReference.this, rightHandType.getQualifiedSourceName());
  }

  private boolean handleMismatchedNonNumericPrimitives(JType leftType, JType rightHandType,
      boolean[] explicitFailure) {
    JPrimitiveType leftPrimitive = leftType.isPrimitive();
    JPrimitiveType rightPrimitive = rightHandType.isPrimitive();

    if (leftPrimitive == null && rightPrimitive == null) {
      return false;
    }

    if (leftPrimitive != null) {
      JClassType autobox = typeOracle.findType(leftPrimitive.getQualifiedBoxedSourceName());
      if (rightHandType != autobox) {
        explicitFailure[0] = true;
      }
    } else { // rightPrimitive != null
      JClassType autobox = typeOracle.findType(rightPrimitive.getQualifiedBoxedSourceName());
      if (leftType != autobox) {
        explicitFailure[0] = true;
      }
    }

    return true;
  }

  private boolean isNumber(JType type) {
    JClassType numberType = typeOracle.findType(Number.class.getCanonicalName());

    JClassType asClass = type.isClass();
    if (asClass != null) {
      return numberType.isAssignableFrom(asClass);
    }

    JPrimitiveType asPrimitive = type.isPrimitive();
    if (asPrimitive != null) {
      JClassType autoboxed = typeOracle.findType(asPrimitive.getQualifiedBoxedSourceName());
      return numberType.isAssignableFrom(autoboxed);
    }

    return false;
  }

  private boolean matchingNumberTypes(JType leftHandType, JType rightHandType) {
    /*
     * int i = (int) 1.0 is okay Integer i = (int) 1.0 is okay int i = (int)
     * Double.valueOf(1.0) is not
     */
    if (isNumber(leftHandType) && isNumber(rightHandType) //
        && (rightHandType.isPrimitive() != null)) {
      return true; // They will be cast into submission
    }

    return false;
  }
}