com.google.javascript.rhino.ErrorReporter Java Examples

private void handleUnresolvedType(
    ErrorReporter t, boolean ignoreForwardReferencedTypes) {
  if (registry.isLastGeneration()) {
    boolean isForwardDeclared =
        ignoreForwardReferencedTypes &&
        registry.isForwardDeclaredType(reference);
    if (!isForwardDeclared && registry.isLastGeneration()) {
      t.warning("Bad type annotation. Unknown type " + reference,
          sourceName, lineno, charno);
    } else {
      setReferencedType(
          registry.getNativeObjectType(
              JSTypeNative.NO_RESOLVED_TYPE));

      if (registry.isLastGeneration() && validator != null) {
        validator.apply(getReferencedType());
      }
    }

    setResolvedTypeInternal(getReferencedType());
  } else {
    setResolvedTypeInternal(this);
  }
}
 

@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> scope) {
  setResolvedTypeInternal(this); // for circularly defined types.

  boolean changed = false;
  ImmutableList.Builder<JSType> resolvedTypes = ImmutableList.builder();
  for (JSType alternate : alternates) {
    JSType newAlternate = alternate.resolve(t, scope);
    changed |= (alternate != newAlternate);
    resolvedTypes.add(alternate);
  }
  if (changed) {
    Collection<JSType> newAlternates = resolvedTypes.build();
    Preconditions.checkState(
        newAlternates.hashCode() == this.hashcode);
    alternates = newAlternates;
  }
  return this;
}
 

private void handleUnresolvedType(
    ErrorReporter t, boolean ignoreForwardReferencedTypes) {
  if (registry.isLastGeneration()) {
    boolean isForwardDeclared =
        ignoreForwardReferencedTypes &&
        registry.isForwardDeclaredType(reference);
    if (!isForwardDeclared && registry.isLastGeneration()) {
      t.warning("Bad type annotation. Unknown type " + reference,
          sourceName, lineno, charno);
    } else {
      setReferencedType(
          registry.getNativeObjectType(
              JSTypeNative.NO_RESOLVED_TYPE));

      if (registry.isLastGeneration() && validator != null) {
        validator.apply(getReferencedType());
      }
    }

    setResolvedTypeInternal(getReferencedType());
  } else {
    setResolvedTypeInternal(this);
  }
}
 

private void setReferencedAndResolvedType(JSType type, ErrorReporter t,
    StaticScope<JSType> enclosing) {
  if (validator != null) {
    validator.apply(type);
  }
  setReferencedType(type);
  checkEnumElementCycle(t);
  checkProtoCycle(t);
  setResolvedTypeInternal(getReferencedType());
}
 

/**
 * Resolves a named type by looking it up in the registry.
 * @return True if we resolved successfully.
 */
private boolean resolveViaRegistry(
    ErrorReporter t, StaticScope<JSType> enclosing) {
  JSType type = registry.getType(reference);
  if (type != null) {
    setReferencedAndResolvedType(type, t, enclosing);
    return true;
  }
  return false;
}
 

@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> scope) {
  setResolvedTypeInternal(this);

  ObjectType implicitPrototype = getImplicitPrototype();
  if (implicitPrototype != null) {
    implicitPrototypeFallback =
        (ObjectType) implicitPrototype.resolve(t, scope);
  }
  for (Property prop : properties.values()) {
    prop.setType(safeResolve(prop.getType(), t, scope));
  }
  return this;
}
 

JSType getTypedefType(ErrorReporter t, StaticSlot<JSType> slot, String name) {
  JSType type = slot.getType();
  if (type != null) {
    return type;
  }
  handleUnresolvedType(t, true);
  return null;
}
 

/**
 * Force this type to resolve, even if the registry is in a lazy
 * resolving mode.
 * @see #resolve
 */
public final JSType forceResolve(ErrorReporter t, StaticScope<JSType> scope) {
  ResolveMode oldResolveMode = registry.getResolveMode();
  registry.setResolveMode(ResolveMode.IMMEDIATE);
  JSType result = resolve(t, scope);
  registry.setResolveMode(oldResolveMode);
  return result;
}
 

/**
 * Resolves a named type by looking up its first component in the scope, and
 * subsequent components as properties. The scope must have been fully
 * parsed and a symbol table constructed.
 */
private void resolveViaProperties(ErrorReporter t,
                                  StaticScope<JSType> enclosing) {
  JSType value = lookupViaProperties(t, enclosing);
  // last component of the chain
  if (value != null && value.isFunctionType() &&
      (value.isConstructor() || value.isInterface())) {
    FunctionType functionType = value.toMaybeFunctionType();
    setReferencedAndResolvedType(
        functionType.getInstanceType(), t, enclosing);
  } else if (value != null && value.isNoObjectType()) {
    setReferencedAndResolvedType(
        registry.getNativeFunctionType(
            JSTypeNative.NO_OBJECT_TYPE).getInstanceType(), t, enclosing);
  } else if (value instanceof EnumType) {
    setReferencedAndResolvedType(
        ((EnumType) value).getElementsType(), t, enclosing);
  } else {
    // We've been running into issues where people forward-declare
    // non-named types. (This is legitimate...our dependency management
    // code doubles as our forward-declaration code.)
    //
    // So if the type does resolve to an actual value, but it's not named,
    // then don't respect the forward declaration.
    handleUnresolvedType(t, value == null || value.isUnknownType());
  }
}
 

/**
 * Resolve this type in the given scope.
 *
 * The returned value must be equal to {@code this}, as defined by
 * {@link #isEquivalentTo}. It may or may not be the same object. This method
 * may modify the internal state of {@code this}, as long as it does
 * so in a way that preserves Object equality.
 *
 * For efficiency, we should only resolve a type once per compilation job.
 * For incremental compilations, one compilation job may need the
 * artifacts from a previous generation, so we will eventually need
 * a generational flag instead of a boolean one.
 */
public final JSType resolve(ErrorReporter t, StaticScope<JSType> scope) {
  if (resolved) {
    // TODO(nicksantos): Check to see if resolve() looped back on itself.
    // Preconditions.checkNotNull(resolveResult);
    if (resolveResult == null) {
      return registry.getNativeType(JSTypeNative.UNKNOWN_TYPE);
    }
    return resolveResult;
  }
  resolved = true;
  resolveResult = resolveInternal(t, scope);
  resolveResult.setResolvedTypeInternal(resolveResult);
  return resolveResult;
}
 

/**
 * Resolves a named type by looking up its first component in the scope, and
 * subsequent components as properties. The scope must have been fully
 * parsed and a symbol table constructed.
 */
private void resolveViaProperties(ErrorReporter t,
                                  StaticScope<JSType> enclosing) {
  JSType value = lookupViaProperties(t, enclosing);
  // last component of the chain
  if (value != null && value.isFunctionType() &&
      (value.isConstructor() || value.isInterface())) {
    FunctionType functionType = value.toMaybeFunctionType();
    setReferencedAndResolvedType(
        functionType.getInstanceType(), t, enclosing);
  } else if (value != null && value.isNoObjectType()) {
    setReferencedAndResolvedType(
        registry.getNativeFunctionType(
            JSTypeNative.NO_OBJECT_TYPE).getInstanceType(), t, enclosing);
  } else if (value instanceof EnumType) {
    setReferencedAndResolvedType(
        ((EnumType) value).getElementsType(), t, enclosing);
  } else {
    // We've been running into issues where people forward-declare
    // non-named types. (This is legitimate...our dependency management
    // code doubles as our forward-declaration code.)
    //
    // So if the type does resolve to an actual value, but it's not named,
    // then don't respect the forward declaration.
    handleUnresolvedType(t, value == null || value.isUnknownType());
  }
}
 

/** @return The resolved type */
public static JSType assertValidResolve(
    JSType type, StaticScope<JSType> scope) {
  ErrorReporter t = TestErrorReporter.forNoExpectedReports();
  JSType resolvedType = type.resolve(t, scope);
  assertTypeEquals("JSType#resolve should not affect object equality",
      type, resolvedType);
  return resolvedType;
}
 

private void handleTypeCycle(ErrorReporter t) {
  setReferencedType(
      registry.getNativeObjectType(JSTypeNative.UNKNOWN_TYPE));
  t.warning("Cycle detected in inheritance chain of type " + reference,
      sourceName, lineno, charno);
  setResolvedTypeInternal(getReferencedType());
}
 

private void checkEnumElementCycle(ErrorReporter t) {
  JSType referencedType = getReferencedType();
  if (referencedType instanceof EnumElementType &&
      ((EnumElementType) referencedType).getPrimitiveType() == this) {
    handleTypeCycle(t);
  }
}
 

/**
 * Resolves a type by looking up its first component in the scope, and
 * subsequent components as properties. The scope must have been fully
 * parsed and a symbol table constructed.
 * @return The type of the symbol, or null if the type could not be found.
 */
private JSType lookupViaProperties( ErrorReporter t,
    StaticScope<JSType> enclosing) {
  String[] componentNames = reference.split("\\.", -1);
  if (componentNames[0].length() == 0) {
    return null;
  }
  StaticSlot<JSType> slot = enclosing.getSlot(componentNames[0]);
  if (slot == null) {
    return null;
  }
  // If the first component has a type of 'Unknown', then any type
  // names using it should be regarded as silently 'Unknown' rather than be
  // noisy about it.
  JSType slotType = slot.getType();
  if (slotType == null || slotType.isAllType() || slotType.isNoType()) {
    return null;
  }
  JSType value = getTypedefType(t, slot, componentNames[0]);
  if (value == null) {
    return null;
  }

  // resolving component by component
  for (int i = 1; i < componentNames.length; i++) {
    ObjectType parentClass = ObjectType.cast(value);
    if (parentClass == null) {
      return null;
    }
    if (componentNames[i].length() == 0) {
      return null;
    }
    value = parentClass.getPropertyType(componentNames[i]);
  }
  return value;
}
 

@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> scope) {
  setResolvedTypeInternal(this);

  ObjectType implicitPrototype = getImplicitPrototype();
  if (implicitPrototype != null) {
    implicitPrototypeFallback =
        (ObjectType) implicitPrototype.resolve(t, scope);
  }
  for (Property prop : properties.values()) {
    prop.setType(safeResolve(prop.getType(), t, scope));
  }
  return this;
}
 

@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> scope) {
  setResolvedTypeInternal(this);

  ObjectType implicitPrototype = getImplicitPrototype();
  if (implicitPrototype != null) {
    implicitPrototypeFallback =
        (ObjectType) implicitPrototype.resolve(t, scope);
  }
  for (Property prop : properties.values()) {
    prop.setType(safeResolve(prop.getType(), t, scope));
  }
  return this;
}
 

@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> scope) {
  setResolvedTypeInternal(this);

  ObjectType implicitPrototype = getImplicitPrototype();
  if (implicitPrototype != null) {
    implicitPrototypeFallback =
        (ObjectType) implicitPrototype.resolve(t, scope);
  }
  for (Property prop : properties.values()) {
    prop.setType(safeResolve(prop.getType(), t, scope));
  }
  return this;
}
 

private void setReferencedAndResolvedType(JSType type, ErrorReporter t,
    StaticScope<JSType> enclosing) {
  if (validator != null) {
    validator.apply(type);
  }
  setReferencedType(type);
  checkEnumElementCycle(t);
  setResolvedTypeInternal(getReferencedType());
}
 

/**
 * Resolves a named type by looking it up in the registry.
 * @return True if we resolved successfully.
 */
private boolean resolveViaRegistry(
    ErrorReporter t, StaticScope<JSType> enclosing) {
  JSType type = registry.getType(reference);
  if (type != null) {
    setReferencedAndResolvedType(type, t, enclosing);
    return true;
  }
  return false;
}
 

/**
 * Resolve the referenced type within the enclosing scope.
 */
@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> enclosing) {
  // TODO(user): Investigate whether it is really necessary to keep two
  // different mechanisms for resolving named types, and if so, which order
  // makes more sense. Now, resolution via registry is first in order to
  // avoid triggering the warnings built into the resolution via properties.
  boolean resolved = resolveViaRegistry(t, enclosing);
  if (detectImplicitPrototypeCycle()) {
    handleTypeCycle(t);
  }

  if (resolved) {
    super.resolveInternal(t, enclosing);
    finishPropertyContinuations();
    return registry.isLastGeneration() ?
        getReferencedType() : this;
  }

  resolveViaProperties(t, enclosing);
  if (detectImplicitPrototypeCycle()) {
    handleTypeCycle(t);
  }

  super.resolveInternal(t, enclosing);
  if (isResolved()) {
    finishPropertyContinuations();
  }
  return registry.isLastGeneration() ?
      getReferencedType() : this;
}
 

private void handleTypeCycle(ErrorReporter t) {
  setReferencedType(
      registry.getNativeObjectType(JSTypeNative.UNKNOWN_TYPE));
  t.warning("Cycle detected in inheritance chain of type " + reference,
      sourceName, lineno, charno);
  setResolvedTypeInternal(getReferencedType());
}
 

private void handleTypeCycle(ErrorReporter t) {
  setReferencedType(
      registry.getNativeObjectType(JSTypeNative.UNKNOWN_TYPE));
  t.warning("Cycle detected in inheritance chain of type " + reference,
      sourceName, lineno, charno);
  setResolvedTypeInternal(getReferencedType());
}
 

private void setReferencedAndResolvedType(JSType type, ErrorReporter t,
    StaticScope<JSType> enclosing) {
  if (validator != null) {
    validator.apply(type);
  }
  setReferencedType(type);
  checkEnumElementCycle(t);
  setResolvedTypeInternal(getReferencedType());
}
 

/**
 * Resolves a type by looking up its first component in the scope, and
 * subsequent components as properties. The scope must have been fully
 * parsed and a symbol table constructed.
 * @return The type of the symbol, or null if the type could not be found.
 */
private JSType lookupViaProperties( ErrorReporter t,
    StaticScope<JSType> enclosing) {
  String[] componentNames = reference.split("\\.", -1);
  if (componentNames[0].length() == 0) {
    return null;
  }
  StaticSlot<JSType> slot = enclosing.getSlot(componentNames[0]);
  if (slot == null) {
    return null;
  }
  // If the first component has a type of 'Unknown', then any type
  // names using it should be regarded as silently 'Unknown' rather than be
  // noisy about it.
  JSType slotType = slot.getType();
  if (slotType == null || slotType.isAllType() || slotType.isNoType()) {
    return null;
  }
  JSType value = getTypedefType(t, slot, componentNames[0]);
  if (value == null) {
    return null;
  }

  // resolving component by component
  for (int i = 1; i < componentNames.length; i++) {
    ObjectType parentClass = ObjectType.cast(value);
    if (parentClass == null) {
      return null;
    }
    if (componentNames[i].length() == 0) {
      return null;
    }
    value = parentClass.getPropertyType(componentNames[i]);
  }
  return value;
}
 

/**
 * Resolves a type by looking up its first component in the scope, and
 * subsequent components as properties. The scope must have been fully
 * parsed and a symbol table constructed.
 * @return The type of the symbol, or null if the type could not be found.
 */
private JSType lookupViaProperties( ErrorReporter t,
    StaticScope<JSType> enclosing) {
  String[] componentNames = reference.split("\\.", -1);
  if (componentNames[0].length() == 0) {
    return null;
  }
  StaticSlot<JSType> slot = enclosing.getSlot(componentNames[0]);
  if (slot == null) {
    return null;
  }
  // If the first component has a type of 'Unknown', then any type
  // names using it should be regarded as silently 'Unknown' rather than be
  // noisy about it.
  JSType slotType = slot.getType();
  if (slotType == null || slotType.isAllType() || slotType.isNoType()) {
    return null;
  }
  JSType value = getTypedefType(t, slot, componentNames[0]);
  if (value == null) {
    return null;
  }

  // resolving component by component
  for (int i = 1; i < componentNames.length; i++) {
    ObjectType parentClass = ObjectType.cast(value);
    if (parentClass == null) {
      return null;
    }
    if (componentNames[i].length() == 0) {
      return null;
    }
    value = parentClass.getPropertyType(componentNames[i]);
  }
  return value;
}
 

/**
 * Resolves a named type by looking it up in the registry.
 * @return True if we resolved successfully.
 */
private boolean resolveViaRegistry(
    ErrorReporter t, StaticScope<JSType> enclosing) {
  JSType type = registry.getType(reference);
  if (type != null) {
    setReferencedAndResolvedType(type, t, enclosing);
    return true;
  }
  return false;
}
 

/**
 * Resolve the referenced type within the enclosing scope.
 */
@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> enclosing) {
  // TODO(user): Investigate whether it is really necessary to keep two
  // different mechanisms for resolving named types, and if so, which order
  // makes more sense. Now, resolution via registry is first in order to
  // avoid triggering the warnings built into the resolution via properties.
  boolean resolved = resolveViaRegistry(t, enclosing);
  if (detectInheritanceCycle()) {
    handleTypeCycle(t);
  }

  if (resolved) {
    super.resolveInternal(t, enclosing);
    finishPropertyContinuations();
    return registry.isLastGeneration() ?
        getReferencedType() : this;
  }

  resolveViaProperties(t, enclosing);
  if (detectInheritanceCycle()) {
    handleTypeCycle(t);
  }

  super.resolveInternal(t, enclosing);
  if (isResolved()) {
    finishPropertyContinuations();
  }
  return registry.isLastGeneration() ?
      getReferencedType() : this;
}
 

@Override
JSType resolveInternal(ErrorReporter t, StaticScope<JSType> scope) {
  for (Map.Entry<String, JSType> entry : properties.entrySet()) {
    JSType type = entry.getValue();
    JSType resolvedType = type.resolve(t, scope);
    if (type != resolvedType) {
      properties.put(entry.getKey(), resolvedType);
    }
  }
  return super.resolveInternal(t, scope);
}
 

/** @return The resolved type */
public static JSType assertValidResolve(
    JSType type, StaticScope<JSType> scope) {
  ErrorReporter t = TestErrorReporter.forNoExpectedReports();
  JSType resolvedType = type.resolve(t, scope);
  assertTypeEquals("JSType#resolve should not affect object equality",
      type, resolvedType);
  return resolvedType;
}