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; }