import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
@Override
protected boolean visitEnumType(EnumType type) {
  Type javaType = createJavaType(type.getDisplayName(), NAMESPACE, false);
  // you cannot extends an enum
  javaType.setFinal(true);

  // The class containing the static fields can be mapped to the javascript Object. The static
  // fields representing the enum members will define a JsProperty annotation with the right
  // name and namespace.
  Annotation jsType = javaType.removeAnnotation(JS_TYPE);
  javaType.addAnnotation(jsType.withNameAttribute("Object").withNamespaceAttribute(""));

  // In closure, the type used for the enum and the type for the enum members are different.
  // In our model, it's the same java type. We need to register the java type two times.
  getJavaTypeRegistry().registerJavaType(javaType, type);
  getJavaTypeRegistry().registerJavaType(javaType, type.getElementsType());

  return false;
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Make sure that the access of this property is ok.
 */
private void checkPropertyAccess(JSType childType, String propName,
    NodeTraversal t, Node n) {
  ObjectType objectType = childType.dereference();
  if (objectType != null) {
    JSType propType = getJSType(n);
    if ((!objectType.hasProperty(propName) ||
         objectType.equals(typeRegistry.getNativeType(UNKNOWN_TYPE))) &&
        propType.equals(typeRegistry.getNativeType(UNKNOWN_TYPE))) {
      if (objectType instanceof EnumType) {
        t.report(n, INEXISTENT_ENUM_ELEMENT, propName);
      } else if (!objectType.isEmptyType() &&
          reportMissingProperties && !isPropertyTest(n)) {
        if (!typeRegistry.canPropertyBeDefined(objectType, propName)) {
          t.report(n, INEXISTENT_PROPERTY, propName,
              validator.getReadableJSTypeName(n.getFirstChild(), true));
        }
      }
    }
  } else {
    // TODO(nicksantos): might want to flag the access on a non object when
    // it's impossible to get a property from this type.
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Handle cases #1 and #3 in the class doc.
 */
private void attachJSDocInfoToNominalTypeOrShape(
    ObjectType objType, JSDocInfo docInfo, @Nullable String qName) {
  if (objType.isConstructor() ||
      objType.isEnumType() ||
      objType.isInterface()) {
    // Named types.
    if (objType.hasReferenceName() &&
        objType.getReferenceName().equals(qName)) {
      objType.setJSDocInfo(docInfo);

      if (objType.isConstructor() || objType.isInterface()) {
        ((FunctionType) objType).getInstanceType().setJSDocInfo(
            docInfo);
      } else if (objType instanceof EnumType) {
        ((EnumType) objType).getElementsType().setJSDocInfo(docInfo);
      }
    }
  } else if (!objType.isNativeObjectType() &&
      objType.isFunctionType()) {
    // Structural functions.
    objType.setJSDocInfo(docInfo);
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Make sure that the access of this property is ok.
 */
private void checkPropertyAccess(JSType childType, String propName,
    NodeTraversal t, Node n) {
  ObjectType objectType = childType.dereference();
  if (objectType != null) {
    JSType propType = getJSType(n);
    if ((!objectType.hasProperty(propName) ||
         objectType.equals(typeRegistry.getNativeType(UNKNOWN_TYPE))) &&
        propType.equals(typeRegistry.getNativeType(UNKNOWN_TYPE))) {
      if (objectType instanceof EnumType) {
        report(t, n, INEXISTENT_ENUM_ELEMENT, propName);
      } else if (!objectType.isEmptyType() &&
          reportMissingProperties && !isPropertyTest(n)) {
        if (!typeRegistry.canPropertyBeDefined(objectType, propName)) {
          report(t, n, INEXISTENT_PROPERTY, propName,
              validator.getReadableJSTypeName(n.getFirstChild(), true));
        }
      }
    }
  } else {
    // TODO(nicksantos): might want to flag the access on a non object when
    // it's impossible to get a property from this type.
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * <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.getScope(), typeRegistry),
      "incompatible enum element types");
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Handle cases #1 and #3 in the class doc.
 */
private void attachJSDocInfoToNominalTypeOrShape(
    ObjectType objType, JSDocInfo docInfo, @Nullable String qName) {
  if (objType.isConstructor() ||
      objType.isEnumType() ||
      objType.isInterface()) {
    // Named types.
    if (objType.hasReferenceName() &&
        objType.getReferenceName().equals(qName)) {
      objType.setJSDocInfo(docInfo);

      if (objType.isConstructor() || objType.isInterface()) {
        JSType.toMaybeFunctionType(objType).getInstanceType().setJSDocInfo(
            docInfo);
      } else if (objType instanceof EnumType) {
        ((EnumType) objType).getElementsType().setJSDocInfo(docInfo);
      }
    }
  } else if (!objType.isNativeObjectType() &&
      objType.isFunctionType()) {
    // Structural functions.
    objType.setJSDocInfo(docInfo);
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * <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");
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Handle cases #1 and #3 in the class doc.
 */
private static void attachJSDocInfoToNominalTypeOrShape(
    ObjectType objType, JSDocInfo docInfo, @Nullable String qName) {
  if (objType.isConstructor() ||
      objType.isEnumType() ||
      objType.isInterface()) {
    // Named types.
    if (objType.hasReferenceName() &&
        objType.getReferenceName().equals(qName)) {
      objType.setJSDocInfo(docInfo);

      if (objType.isConstructor() || objType.isInterface()) {
        JSType.toMaybeFunctionType(objType).getInstanceType().setJSDocInfo(docInfo);
      } else if (objType instanceof EnumType) {
        ((EnumType) objType).getElementsType().setJSDocInfo(docInfo);
      }
    }
  } else if (!objType.isNativeObjectType() && objType.isFunctionType()) {
    // Structural functions.
    objType.setJSDocInfo(docInfo);
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Handle cases #1 and #3 in the class doc.
 */
private static void attachJSDocInfoToNominalTypeOrShape(
    ObjectType objType, JSDocInfo docInfo, @Nullable String qName) {
  if (objType.isConstructor() ||
      objType.isEnumType() ||
      objType.isInterface()) {
    // Named types.
    if (objType.hasReferenceName() &&
        objType.getReferenceName().equals(qName)) {
      objType.setJSDocInfo(docInfo);

      if (objType.isConstructor() || objType.isInterface()) {
        JSType.toMaybeFunctionType(objType).getInstanceType().setJSDocInfo(
            docInfo);
      } else if (objType instanceof EnumType) {
        ((EnumType) objType).getElementsType().setJSDocInfo(docInfo);
      }
    }
  } else if (!objType.isNativeObjectType() &&
      objType.isFunctionType()) {
    // Structural functions.
    objType.setJSDocInfo(docInfo);
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
@Override
protected boolean visitEnumType(EnumType type) {
  // Create a method getValue() that returns the real value of the enum member at runtime.
  Method m = new Method();
  m.setName("getValue");
  m.setFinal(true);
  m.addAnnotation(Annotation.builder().type(JS_OVERLAY).build());
  TypeReference returnType =
      getJavaTypeRegistry().createTypeReference(type.getElementsType().getPrimitiveType());
  TypeReference uncheckedCastTypeParameter =
      getJavaTypeRegistry()
          .createTypeReference(type.getElementsType().getPrimitiveType(), IN_TYPE_ARGUMENTS);
  m.setReturnType(returnType);
  m.setBody(
      new ReturnStatement(
          new MethodInvocation(
              new TypeQualifier(PredefinedTypeReference.JS),
              "uncheckedCast",
              ImmutableList.of(OBJECT),
              ImmutableList.of(LiteralExpression.THIS),
              ImmutableList.of(uncheckedCastTypeParameter))));

  getCurrentJavaType().addMethod(m);

  // add a private constructor to disallow instantiation
  Method privateConstructor = Method.newConstructor();
  privateConstructor.setAccessModifier(PRIVATE);
  getCurrentJavaType().addMethod(privateConstructor);

  return true;
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
private void acceptEnumType(EnumType type) {
  pushCurrentJavaType(type);

  if (visitEnumType(type)) {
    type.getOwnPropertyNames()
        .stream()
        .sorted()
        .forEach(propertyName -> acceptEnumMember(type.getOwnSlot(propertyName)));
  }

  endVisitEnumType(type);

  popCurrentJavaType();
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * <p>Checks the initializer of an enum. An enum can be initialized with an
 * object literal whose values must be subtypes of the declared enum element
 * type, or by copying another enum.</p>
 *
 * <p>In the case of an enum copy, 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>Examples:</p>
 * <pre>var myEnum = {FOO: ..., BAR: ...};
 * var myEnum = myOtherEnum;</pre>
 *
 * @param value the value used for initialization of the enum
 * @param primitiveType The type of each element of the enum.
 */
private void checkEnumInitializer(
    NodeTraversal t, Node value, JSType primitiveType) {
  if (value.getType() == Token.OBJECTLIT) {
    // re-using value as the value of the object literal and advancing twice
    value = value.getFirstChild();
    value = (value == null) ? null : value.getNext();
    while (value != null) {
      // the value's type must be assignable to the enum's primitive type
      validator.expectCanAssignTo(t, value, getJSType(value), primitiveType,
          "element type must match enum's type");

      // advancing twice
      value = value.getNext();
      value = (value == null) ? null : value.getNext();
    }
  } else if (value.getJSType() instanceof EnumType) {
    // TODO(user): Remove the instanceof check in favor
    // of a type.isEnumType() predicate. Currently, not all enum types are
    // implemented by the EnumClass, e.g. the unknown type and the any
    // type. The types need to be defined by interfaces such that an
    // implementation can implement multiple types interface.
    EnumType valueEnumType = (EnumType) value.getJSType();
    JSType valueEnumPrimitiveType =
        valueEnumType.getElementsType().getPrimitiveType();
    validator.expectCanAssignTo(t, value, valueEnumPrimitiveType,
        primitiveType, "incompatible enum element types");
  } else {
    // The error condition is handled in TypedScopeCreator.
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
public void testEnum() {
  testSame("/** @enum */ var Foo = {BAR: 1}; var f = Foo;");
  ObjectType f = (ObjectType) findNameType("f", globalScope);
  assertTrue(f.hasProperty("BAR"));
  assertEquals("Foo.<number>", f.getPropertyType("BAR").toString());
  assertTrue(f instanceof EnumType);
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
public void testEnumAlias() {
  testSame("/** @enum */ var Foo = {BAR: 1}; " +
      "/** @enum */ var FooAlias = Foo; var f = FooAlias;");

  assertEquals("Foo.<number>",
      registry.getType("FooAlias").toString());
  assertEquals(registry.getType("FooAlias"),
      registry.getType("Foo"));

  ObjectType f = (ObjectType) findNameType("f", globalScope);
  assertTrue(f.hasProperty("BAR"));
  assertEquals("Foo.<number>", f.getPropertyType("BAR").toString());
  assertTrue(f instanceof EnumType);
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
/**
 * Emit a warning if we can prove that a property cannot possibly be
 * defined on an object. Note the difference between JS and a strictly
 * statically typed language: we're checking if the property
 * *cannot be defined*, whereas a java compiler would check if the
 * property *can be undefined*.
 */
private void checkPropertyAccess(JSType childType, String propName,
    NodeTraversal t, Node n) {
  // If the property type is unknown, check the object type to see if it
  // can ever be defined. We explicitly exclude CHECKED_UNKNOWN (for
  // properties where we've checked that it exists, or for properties on
  // objects that aren't in this binary).
  JSType propType = getJSType(n);
  if (propType.isEquivalentTo(typeRegistry.getNativeType(UNKNOWN_TYPE))) {
    childType = childType.autobox();
    ObjectType objectType = ObjectType.cast(childType);
    if (objectType != null) {
      // We special-case object types so that checks on enums can be
      // much stricter, and so that we can use hasProperty (which is much
      // faster in most cases).
      if (!objectType.hasProperty(propName) ||
          objectType.isEquivalentTo(
              typeRegistry.getNativeType(UNKNOWN_TYPE))) {
        if (objectType instanceof EnumType) {
          report(t, n, INEXISTENT_ENUM_ELEMENT, propName);
        } else {
          checkPropertyAccessHelper(objectType, propName, t, n);
        }
      }

    } else {
      checkPropertyAccessHelper(childType, propName, t, n);
    }
  }
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
public void testEnumAlias() {
  testSame("/** @enum */ var Foo = {BAR: 1}; " +
      "/** @enum */ var FooAlias = Foo; var f = FooAlias;");

  assertEquals("Foo.<number>",
      registry.getType("FooAlias").toString());
  Asserts.assertTypeEquals(registry.getType("FooAlias"),
      registry.getType("Foo"));

  ObjectType f = (ObjectType) findNameType("f", globalScope);
  assertTrue(f.hasProperty("BAR"));
  assertEquals("Foo.<number>", f.getPropertyType("BAR").toString());
  assertTrue(f instanceof EnumType);
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
public void testEnum() {
  testSame("/** @enum */ var Foo = {BAR: 1}; var f = Foo;");
  ObjectType f = (ObjectType) findNameType("f", globalScope);
  assertTrue(f.hasProperty("BAR"));
  assertEquals("Foo<number>", f.getPropertyType("BAR").toString());
  assertThat(f).isInstanceOf(EnumType.class);
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
public void testEnumAlias() {
  testSame("/** @enum */ var Foo = {BAR: 1}; " +
      "/** @enum */ var FooAlias = Foo; var f = FooAlias;");

  assertEquals("Foo<number>",
      registry.getType("FooAlias").toString());
  Asserts.assertTypeEquals(registry.getType("FooAlias"),
      registry.getType("Foo"));

  ObjectType f = (ObjectType) findNameType("f", globalScope);
  assertTrue(f.hasProperty("BAR"));
  assertEquals("Foo<number>", f.getPropertyType("BAR").toString());
  assertThat(f).isInstanceOf(EnumType.class);
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
protected boolean visitEnumType(EnumType type) {
  return true;
}
 

import com.google.javascript.rhino.jstype.EnumType; //导入依赖的package包/类
private static EnumType toEnumType(JSType type) {
  return checkNotNull(type.toMaybeEnumType());
}