Skip to content

Commit

Permalink
[NTI] s/finalize/freeze/g
Browse files Browse the repository at this point in the history 
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=152734004
  • Loading branch information
@shicks @brad4d
shicks authored and brad4d committed Apr 11, 2017
1 parent 8315486 commit 3a775bf
Show file tree
Hide file tree
Showing 6 changed files with 63 additions and 64 deletions.
40 changes: 20 additions & 20 deletions src/com/google/javascript/jscomp/GlobalTypeInfo.java
View file
Expand Up @@ -477,21 +477,21 @@ public void process(Node externs, Node root) {
win = rawType;
continue;
}
checkAndFinalizeNominalType(rawType);
checkAndFreezeNominalType(rawType);
}
JSType globalThisType;
if (win != null) {
// Copy properties from window to Window.prototype, because sometimes
// people pass window around rather than using it directly.
// Copying the properties is correct only when there is a single object
// of type Window in the program. But in very rare cases, people subclass Window.
// Then, win is finalized here and we don't copy the properties.
// Window has been subclassed iff it is already finalized here.
// Then, win is frozen here and we don't copy the properties.
// Window has been subclassed iff it is already frozen here.
Namespace winNs = this.globalScope.getNamespace(WINDOW_INSTANCE);
if (winNs != null && !win.isFinalized()) {
if (winNs != null && !win.isFrozen()) {
winNs.copyWindowProperties(this.commonTypes, win);
}
checkAndFinalizeNominalType(win);
checkAndFreezeNominalType(win);
// Type the global THIS as window
globalThisType = win.getInstanceAsJSType();
} else {
Expand All @@ -505,7 +505,7 @@ public void process(Node externs, Node root) {
nominaltypesByNode = null;
propertyDefs = null;
for (NTIScope s : scopes) {
s.finalizeScope();
s.freezeScope();
}

// Traverse the externs and annotate them with types.
Expand Down Expand Up @@ -577,7 +577,7 @@ private JSType simpleInferDeclaration(Declaration decl) {
}

private Collection<PropertyDef> getPropDefsFromInterface(NominalType nominalType, String pname) {
Preconditions.checkArgument(nominalType.isFinalized());
Preconditions.checkArgument(nominalType.isFrozen());
Preconditions.checkArgument(nominalType.isInterface() || nominalType.isBuiltinObject());
if (nominalType.getPropDeclaredType(pname) == null) {
return ImmutableSet.of();
Expand All @@ -595,7 +595,7 @@ private Collection<PropertyDef> getPropDefsFromInterface(NominalType nominalType

private PropertyDef getPropDefFromClass(NominalType nominalType, String pname) {
while (nominalType.getPropDeclaredType(pname) != null) {
Preconditions.checkArgument(nominalType.isFinalized());
Preconditions.checkArgument(nominalType.isFrozen());
Preconditions.checkArgument(nominalType.isClass());

if (propertyDefs.get(nominalType.getId(), pname) != null) {
Expand All @@ -607,18 +607,18 @@ private PropertyDef getPropDefFromClass(NominalType nominalType, String pname) {
return null;
}

private void checkAndFinalizeNominalType(RawNominalType rawType) {
if (rawType.isFinalized()) {
private void checkAndFreezeNominalType(RawNominalType rawType) {
if (rawType.isFrozen()) {
return;
}
NominalType superClass = rawType.getSuperClass();
Set<String> nonInheritedPropNames = rawType.getAllOwnProps();
if (superClass != null && !superClass.isFinalized()) {
checkAndFinalizeNominalType(superClass.getRawNominalType());
if (superClass != null && !superClass.isFrozen()) {
checkAndFreezeNominalType(superClass.getRawNominalType());
}
for (NominalType superInterf : rawType.getInterfaces()) {
if (!superInterf.isFinalized()) {
checkAndFinalizeNominalType(superInterf.getRawNominalType());
if (!superInterf.isFrozen()) {
checkAndFreezeNominalType(superInterf.getRawNominalType());
}
}

Expand All @@ -627,7 +627,7 @@ private void checkAndFinalizeNominalType(RawNominalType rawType) {
Multimap<String, JSType> propTypesToProcess = LinkedHashMultimap.create();
// Collect inherited types for extended classes
if (superClass != null) {
Preconditions.checkState(superClass.isFinalized());
Preconditions.checkState(superClass.isFrozen());
// TODO(blickly): Can we optimize this to skip unnecessary iterations?
for (String pname : superClass.getAllPropsOfClass()) {
if (superClass.isAbstractClass()
Expand All @@ -646,7 +646,7 @@ private void checkAndFinalizeNominalType(RawNominalType rawType) {

// Collect inherited types for extended/implemented interfaces
for (NominalType superInterf : rawType.getInterfaces()) {
Preconditions.checkState(superInterf.isFinalized());
Preconditions.checkState(superInterf.isFrozen());
for (String pname : superInterf.getAllPropsOfInterface()) {
nonInheritedPropNames.remove(pname);
checkSuperProperty(rawType, superInterf, pname,
Expand Down Expand Up @@ -742,12 +742,12 @@ private void checkAndFinalizeNominalType(RawNominalType rawType) {
}
}

// Finalize nominal type once all properties are added.
rawType.finalize();
// Freeze nominal type once all properties are added.
rawType.freeze();
if (rawType.isBuiltinObject()) {
NominalType literalObj = this.commonTypes.getLiteralObjNominalType();
if (!literalObj.isFinalized()) {
literalObj.getRawNominalType().finalize();
if (!literalObj.isFrozen()) {
literalObj.getRawNominalType().freeze();
}
}
}
Expand Down
14 changes: 7 additions & 7 deletions src/com/google/javascript/jscomp/NTIScope.java
View file
Expand Up @@ -52,8 +52,8 @@ final class NTIScope implements DeclaredTypeRegistry {
// Name on the function AST node; null for top scope & anonymous functions
private final String name;
private final JSTypes commonTypes;
// Becomes true after finalizeScope is run; so it's true during NTI.
private boolean isFinalized = false;
// Becomes true after freezeScope is run; so it's true during NTI.
private boolean isFrozen = false;

// A local w/out declared type is mapped to null, not to this.commonTypes.UNKNOWN.
private final Map<String, JSType> locals = new LinkedHashMap<>();
Expand All @@ -66,7 +66,7 @@ final class NTIScope implements DeclaredTypeRegistry {
// and are defined in an outer scope.
private final Set<String> outerVars = new LinkedHashSet<>();
// When a function is also used as a namespace, we add entries to both
// localFunDefs and localNamespaces. After finalizeScope (when NTI runs),
// localFunDefs and localNamespaces. After freezeScope (when NTI runs),
// the function has an entry in localFunDefs, and in locals or externs.
private final Map<String, NTIScope> localFunDefs = new LinkedHashMap<>();
private ImmutableSet<String> unknownTypeNames = ImmutableSet.of();
Expand Down Expand Up @@ -187,7 +187,7 @@ boolean isLocalFunDef(String name) {

boolean isFunctionNamespace(String name) {
Preconditions.checkArgument(!name.contains("."));
Preconditions.checkState(isFinalized);
Preconditions.checkState(isFrozen);
Declaration d = getDeclaration(name, false);
if (d == null || d.getFunctionScope() == null || d.getTypeOfSimpleDecl() == null) {
return false;
Expand Down Expand Up @@ -573,7 +573,7 @@ private Declaration getLocalDeclaration(String name, boolean includeTypes) {
} else if (localFunDefs.containsKey(name)) {
// After finalization, the externs contain the correct type for
// external function namespaces, don't rely on localFunDefs
if (isFinalized && externs.containsKey(name)) {
if (isFrozen && externs.containsKey(name)) {
type = externs.get(name);
}
} else if (localTypedefs.containsKey(name) || localNamespaces.containsKey(name)) {
Expand Down Expand Up @@ -656,7 +656,7 @@ void resolveEnums(JSTypeCreatorFromJSDoc typeParser) {
localEnums = null;
}

void finalizeScope() {
void freezeScope() {
Preconditions.checkNotNull(this.declaredType, "No declared type for scope: %s", this.root);
unknownTypeNames = ImmutableSet.of();
// For now, we put types of namespaces directly into the locals.
Expand Down Expand Up @@ -690,7 +690,7 @@ void finalizeScope() {
localNamespaces = ImmutableMap.of();
localTypedefs = ImmutableMap.of();
escapedVars = ImmutableSet.of();
isFinalized = true;
isFrozen = true;
}

// A scope must know about the free variables used in outer scopes,
Expand Down
6 changes: 3 additions & 3 deletions src/com/google/javascript/jscomp/newtypes/Namespace.java
View file
Expand Up @@ -33,7 +33,7 @@
*/
public abstract class Namespace {
private Map<String, Namespace> namespaces = ImmutableMap.of();
// Finalize the namespace after GTI and null-out the typedefs.
// Freeze the namespace after GTI and null-out the typedefs.
private Map<String, Typedef> typedefs = ImmutableMap.of();
// "Simple type" properties (i.e. represented as JSTypes rather than something
// more specific).
Expand Down Expand Up @@ -257,9 +257,9 @@ public final void copyWindowProperties(JSTypes commonTypes, RawNominalType win)
if (ns instanceof RawNominalType) {
RawNominalType rawType = (RawNominalType) ns;
// Hack: circular namespace here, skip adding Window.
if (!rawType.isFinalized()) {
if (!rawType.isFrozen()) {
Preconditions.checkState(rawType.getName().equals("Window"),
"Unexpected unfinalized type %s", rawType.getName());
"Unexpected unfrozen type %s", rawType.getName());
continue;
}
}
Expand Down
20 changes: 10 additions & 10 deletions src/com/google/javascript/jscomp/newtypes/NominalType.java
View file
Expand Up @@ -55,8 +55,8 @@ public final class NominalType {
// expect fully-instantiated types for properties defined on types, etc., but by accessing
// the raw nominal type directly they will get the uninstantiated generic types instead.
public RawNominalType getRawNominalType() {
// If the raw nominal type is finalized, then we are not in GlobalTypeInfo any more.
Preconditions.checkState(!this.rawType.isFinalized());
// If the raw nominal type is frozen, then we are not in GlobalTypeInfo any more.
Preconditions.checkState(!this.rawType.isFrozen());
return this.rawType;
}

Expand Down Expand Up @@ -284,8 +284,8 @@ boolean isStructuralInterface() {
return this.rawType.isStructuralInterface();
}

public boolean isFinalized() {
return this.rawType.isFinalized();
public boolean isFrozen() {
return this.rawType.isFrozen();
}

boolean hasAncestorClass(RawNominalType ancestor) {
Expand All @@ -309,22 +309,22 @@ public Set<String> getAllOwnClassProps() {
}

public NominalType getInstantiatedSuperclass() {
Preconditions.checkState(this.rawType.isFinalized());
Preconditions.checkState(this.rawType.isFrozen());
if (this.rawType.getSuperClass() == null) {
return null;
}
return this.rawType.getSuperClass().instantiateGenerics(typeMap);
}

public JSType getPrototypePropertyOfCtor() {
Preconditions.checkState(this.rawType.isFinalized());
Preconditions.checkState(this.rawType.isFrozen());
return this.rawType.getCtorPropDeclaredType("prototype");
}

// We require finalization for the interfaces here because the inheritance
// chain of each type may not be correct until after the type is finalized.
// chain of each type may not be correct until after the type is frozen.
public ImmutableSet<NominalType> getInstantiatedInterfaces() {
Preconditions.checkState(this.rawType.isFinalized());
Preconditions.checkState(this.rawType.isFrozen());
ImmutableSet.Builder<NominalType> result = ImmutableSet.builder();
for (NominalType interf : this.rawType.getInterfaces()) {
result.add(interf.instantiateGenerics(typeMap));
Expand All @@ -333,7 +333,7 @@ public ImmutableSet<NominalType> getInstantiatedInterfaces() {
}

// The main difference from getInstantiatedInterfaces is that this method
// can be used on non-finalized types.
// can be used on non-frozen types.
private ImmutableSet<NominalType> getInstantiatedIObjectInterfaces() {
ImmutableSet.Builder<NominalType> result = ImmutableSet.builder();
for (NominalType interf : this.rawType.getInterfaces()) {
Expand Down Expand Up @@ -437,7 +437,7 @@ boolean isNominalSubtypeOf(NominalType other) {
return true;
}
if (other.isInterface()) {
// If thisRaw is not finalized, thisRaw.interfaces may be null.
// If thisRaw is not frozen, thisRaw.interfaces may be null.
for (NominalType i : thisRaw.getInterfaces()) {
if (i.instantiateGenerics(this.typeMap).isNominalSubtypeOf(other)) {
return true;
Expand Down
2 changes: 1 addition & 1 deletion src/com/google/javascript/jscomp/newtypes/ObjectType.java
View file
Expand Up @@ -1331,7 +1331,7 @@ boolean unifyWithSubtype(ObjectType other, List<String> typeParameters,
}
Set<String> thisProps = !thisNt.isBuiltinObject() && thisNt.isStructuralInterface()
? thisNt.getAllPropsOfInterface() : this.props.keySet();
if (thisProps == null) {// Can happen during GTI when types aren't finalized yet.
if (thisProps == null) {// Can happen during GTI when types aren't frozen yet.
return true;
}
return unifyPropsWithSubtype(other, thisProps, typeParameters, typeMultimap, subSuperMap);
Expand Down

0 comments on commit 3a775bf

Please sign in to comment.