JSType meet(JSType that) {
UnionTypeBuilder builder = new UnionTypeBuilder(registry);
for (JSType alternate : alternatesWithoutStucturalTyping) {
if (alternate.isSubtype(that)) {
builder.addAlternate(alternate);
}
}
if (that.isUnionType()) {
for (JSType otherAlternate : that.toMaybeUnionType().alternatesWithoutStucturalTyping) {
if (otherAlternate.isSubtype(this)) {
builder.addAlternate(otherAlternate);
}
}
} else if (that.isSubtype(this)) {
builder.addAlternate(that);
}
JSType result = builder.build();
if (!result.isNoType()) {
return result;
} else if (this.isObject() && (that.isObject() && !that.isNoType())) {
return getNativeType(JSTypeNative.NO_OBJECT_TYPE);
} else {
return getNativeType(JSTypeNative.NO_TYPE);
}
}
/**
* 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 reporter, StaticTypedScope<JSType> enclosing) {
String[] componentNames = reference.split("\\.", -1);
if (componentNames[0].length() == 0) {
return null;
}
StaticTypedSlot<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(reporter, slot);
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
public boolean isSubtype(JSType that) {
if (JSType.isSubtype(this, that)) {
return true;
} else {
return that.isObject() && !that.isNoType() && !that.isNoResolvedType();
}
}
/** Adds an alternate to the union type under construction. Returns this for easy chaining. */
public UnionTypeBuilder addAlternate(JSType alternate, boolean isStructural) {
// build() returns the bottom type by default, so we can
// just bail out early here.
if (alternate.isNoType()) {
return this;
}
isAllType = isAllType || alternate.isAllType();
containsVoidType = containsVoidType || alternate.isVoidType();
boolean isAlternateUnknown = alternate instanceof UnknownType;
isNativeUnknownType = isNativeUnknownType || isAlternateUnknown;
if (isAlternateUnknown) {
areAllUnknownsChecked = areAllUnknownsChecked && alternate.isCheckedUnknownType();
}
if (!isAllType && !isNativeUnknownType) {
if (alternate.isUnionType()) {
UnionType union = alternate.toMaybeUnionType();
for (JSType unionAlt : union.getAlternatesWithoutStructuralTyping()) {
addAlternate(unionAlt);
}
} else {
if (alternates.size() > maxUnionSize) {
return this;
}
// Function types are special, because they have their
// own bizarre sub-lattice. See the comments on
// FunctionType#supAndInf helper and above at functionTypePosition.
if (alternate.isFunctionType() && functionTypePosition != -1) {
// See the comments on functionTypePosition above.
FunctionType other = alternates.get(functionTypePosition).toMaybeFunctionType();
FunctionType supremum = alternate.toMaybeFunctionType().supAndInfHelper(other, true);
alternates.set(functionTypePosition, supremum);
result = null;
return this;
}
// Look through the alternates we've got so far,
// and check if any of them are duplicates of
// one another.
int currentIndex = 0;
Iterator<JSType> it = alternates.iterator();
while (it.hasNext()) {
boolean removeCurrent = false;
JSType current = it.next();
// Unknown and NoResolved types may just be names that haven't
// been resolved yet. So keep these in the union, and just use
// equality checking for simple de-duping.
if (alternate.isUnknownType()
|| current.isUnknownType()
|| alternate.isNoResolvedType()
|| current.isNoResolvedType()
|| alternate.hasAnyTemplateTypes()
|| current.hasAnyTemplateTypes()) {
if (alternate.isEquivalentTo(current, isStructural)) {
// Alternate is unnecessary.
return this;
}
} else {
// Because "Foo" and "Foo.<?>" are roughly equivalent
// templatized types, special care is needed when building the
// union. For example:
// Object is consider a subtype of Object.<string>
// but we want to leave "Object" not "Object.<string>" when
// building the subtype.
//
if (alternate.isTemplatizedType() || current.isTemplatizedType()) {
// Cases:
// 1) alternate:Array.<string> and current:Object ==> Object
// 2) alternate:Array.<string> and current:Array ==> Array
// 3) alternate:Object.<string> and
// current:Array ==> Array|Object.<string>
// 4) alternate:Object and current:Array.<string> ==> Object
// 5) alternate:Array and current:Array.<string> ==> Array
// 6) alternate:Array and
// current:Object.<string> ==> Array|Object.<string>
// 7) alternate:Array.<string> and
// current:Array.<number> ==> Array.<?>
// 8) alternate:Array.<string> and
// current:Array.<string> ==> Array.<string>
// 9) alternate:Array.<string> and
// current:Object.<string> ==> Object.<string>|Array.<string>
if (!current.isTemplatizedType()) {
if (isSubtype(alternate, current, isStructural)) {
// case 1, 2
return this;
}
// case 3: leave current, add alternate
} else if (!alternate.isTemplatizedType()) {
if (isSubtype(current, alternate, isStructural)) {
// case 4, 5
removeCurrent = true;
}
// case 6: leave current, add alternate
} else {
Preconditions.checkState(
current.isTemplatizedType() && alternate.isTemplatizedType());
TemplatizedType templatizedAlternate = alternate.toMaybeTemplatizedType();
TemplatizedType templatizedCurrent = current.toMaybeTemplatizedType();
if (templatizedCurrent.wrapsSameRawType(templatizedAlternate)) {
if (alternate
.getTemplateTypeMap()
.checkEquivalenceHelper(
current.getTemplateTypeMap(),
EquivalenceMethod.IDENTITY,
SubtypingMode.NORMAL)) {
// case 8
return this;
} else {
// TODO(johnlenz): should we leave both types?
// case 7: add a merged alternate
// We currently merge to the templatized types to "unknown"
// which is equivalent to the raw type.
JSType merged = templatizedCurrent.getReferencedObjTypeInternal();
return addAlternate(merged);
}
}
// case 9: leave current, add alternate
}
// Otherwise leave both templatized types.
} else if (isSubtype(alternate, current, isStructural)) {
// Alternate is unnecessary.
return this;
} else if (isSubtype(current, alternate, isStructural)) {
// Alternate makes current obsolete
removeCurrent = true;
}
}
if (removeCurrent) {
it.remove();
if (currentIndex == functionTypePosition) {
functionTypePosition = -1;
} else if (currentIndex < functionTypePosition) {
functionTypePosition--;
currentIndex--;
}
}
currentIndex++;
}
if (alternate.isFunctionType()) {
// See the comments on functionTypePosition above.
Preconditions.checkState(functionTypePosition == -1);
functionTypePosition = alternates.size();
}
alternates.add(alternate);
result = null; // invalidate the memoized result
}
} else {
result = null;
}
return this;
}