/** * Determines whether the given type is one whose properties should not be * considered for renaming. */ private boolean isTypeToSkip(JSType type) { return type.isEnumType() || type.isBoxableScalar(); }
/** * Determines whether the given type is one whose properties should not be * considered for renaming. */ private boolean isTypeToSkip(JSType type) { return type.isEnumType() || (type.autoboxesTo() != null); }
@Override public boolean matches(Node node, NodeMetadata metadata) { JSType jsType = node.getJSType(); return jsType != null && jsType.isEnumType(); } };
/** * Returns true if {@code propType} is creating a new type in the TypeScript sense - i.e. it's a * constructor function (class or interface), enum, or typedef. */ private boolean isDefiningType(JSType propType) { return isClassLike(propType) || propType.isEnumType() || propType.isInterface() || isTypedef(propType); }
private boolean isPrivate(JSType type) { // Due to https://github.com/google/closure-compiler/issues/1975 we cannot obtain the JSDoc // for a typedef. Assume non-private as it is more common. // Closure creates a NamedType when the typedef is used in an union, eg: T | null. // Dereference the named type before checking if it is a typedef. NamedType nType = type.toMaybeNamedType(); if (typedefs.containsKey(type) || (nType != null && typedefs.containsKey(nType.getReferencedType()))) { return false; } // For unknown reasons, enum types do not keep their defining jsdoc info. if (type.isEnumType() || type.isEnumElementType()) { return isPrivate(type.getDisplayName()); } else { return isPrivate(type.getJSDocInfo()); } }
@Override public boolean matches(Node node, NodeMetadata metadata) { JSType providedJsType = getJsType(metadata, type); if (providedJsType == null) { return false; } providedJsType = providedJsType.restrictByNotNullOrUndefined(); JSType jsType = node.getJSType(); return jsType != null && jsType.isEnumType() && providedJsType.isEquivalentTo( jsType.toMaybeEnumType().getElementsType().getPrimitiveType()); } };
String qualifiedName = innerNamespace + '.' + propName; if (provides.contains(qualifiedName)) continue; if (pType.isEnumType()) { if (!foundNamespaceMembers) { emitNamespaceBegin(innerNamespace);
if (type.isEnumType()) { EnumType eType = (EnumType) type; for (String element : eType.getElements()) {
&& (getType(owner).isNominalConstructor() || getType(owner).isFunctionPrototypeType() || getType(owner).isEnumType())) { removeSymbol(s); continue nextSymbol;
&& (getType(owner).isNominalConstructor() || getType(owner).isFunctionPrototypeType() || getType(owner).isEnumType())) { removeSymbol(s); continue nextSymbol;
private boolean isDefaultExport(TypedVar symbol) { if (symbol.getType() == null) return true; ObjectType otype = symbol.getType().toMaybeObjectType(); if (otype != null && otype.getOwnPropertyNames().size() == 0) return true; return !symbol.getType().isObject() || symbol.getType().isInterface() || symbol.getType().isInstanceType() || symbol.getType().isEnumType() || symbol.getType().isFunctionType() || isTypedef(symbol.getType()); }
if (!valueType.isEnumType()) { return;
/** * <p>Checks enum aliases. * * <p>We verify that the enum element type of the enum used * for initialization is a subtype of the enum element type of * the enum the value is being copied in.</p> * * <p>Example:</p> * <pre>var myEnum = myOtherEnum;</pre> * * <p>Enum aliases are irregular, so we need special code for this :(</p> * * @param value the value used for initialization of the enum */ private void checkEnumAlias( NodeTraversal t, JSDocInfo declInfo, Node value) { if (declInfo == null || !declInfo.hasEnumParameterType()) { return; } JSType valueType = getJSType(value); if (!valueType.isEnumType()) { return; } EnumType valueEnumType = valueType.toMaybeEnumType(); JSType valueEnumPrimitiveType = valueEnumType.getElementsType().getPrimitiveType(); validator.expectCanAssignTo(t, value, valueEnumPrimitiveType, declInfo.getEnumParameterType().evaluate(t.getTypedScope(), typeRegistry), "incompatible enum element types"); }
private boolean maybeDefineTypedReference(Node n, String propName, JSType owner) { if (owner.isGlobalThisType()) { Symbol sym = globalScope.getSlot(propName); if (sym != null) { sym.defineReferenceAt(n); return true; } } else if (owner.isNominalConstructor()) { return maybeDefineReference(n, propName, getSymbolDeclaredBy(owner.toMaybeFunctionType())); } else if (owner.isEnumType()) { return maybeDefineReference(n, propName, getSymbolDeclaredBy(owner.toMaybeEnumType())); } else { boolean defined = false; for (Symbol ctor : getAllSymbolsForType(owner)) { if (maybeDefineReference(n, propName, getSymbolForInstancesOf(ctor))) { defined = true; } } return defined; } return false; }
private boolean maybeDefineTypedReference( Node n, String propName, JSType owner) { if (owner.isGlobalThisType()) { Symbol sym = globalScope.getSlot(propName); if (sym != null) { sym.defineReferenceAt(n); return true; } } else if (owner.isNominalConstructor()) { return maybeDefineReference( n, propName, getSymbolDeclaredBy(owner.toMaybeFunctionType())); } else if (owner.isEnumType()) { return maybeDefineReference( n, propName, getSymbolDeclaredBy(owner.toMaybeEnumType())); } else { boolean defined = false; for (Symbol ctor : getAllSymbolsForType(owner)) { if (maybeDefineReference( n, propName, getSymbolForInstancesOf(ctor))) { defined = true; } } return defined; } return false; }
private String getTypeAnnotation(Node node) { // Only add annotations for things with JSDoc, or function literals. JSDocInfo jsdoc = NodeUtil.getBestJSDocInfo(node); if (jsdoc == null && !node.isFunction()) { return ""; } JSType type = node.getJSType(); if (type == null) { return ""; } else if (type.isFunctionType()) { return getFunctionAnnotation(node); } else if (type.isEnumType()) { return "/** @enum {" + type.toMaybeEnumType().getElementsType().toAnnotationString() + "} */\n"; } else if (!type.isUnknownType() && !type.isEmptyType() && !type.isVoidType() && !type.isFunctionPrototypeType()) { return "/** @type {" + node.getJSType().toAnnotationString() + "} */\n"; } else { return ""; } }
if (type.isEnumType()) { visitEnumType(emitName, emitName, (EnumType) type, symbol.getNode()); return;
if (rawType.isEnumType()) { return rawType.toMaybeEnumType().getElementsType();
} else if (type.isFunctionType()) { return getFunctionAnnotation(node); } else if (type.isEnumType()) { return "/** @enum {" + type.toMaybeObjectType()