Java JSType.toObjectType方法代码示例

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
/**
 * Expect that the first type can be addressed with GETELEM syntax,
 * and that the second type is the right type for an index into the
 * first type.
 *
 * @param t The node traversal.
 * @param n The node to issue warnings on.
 * @param objType The type of the left side of the GETELEM.
 * @param indexType The type inside the brackets of the GETELEM.
 */
void expectIndexMatch(NodeTraversal t, Node n, JSType objType,
    JSType indexType) {
  if (objType.isUnknownType()) {
    expectStringOrNumber(t, n, indexType, "property access");
  } else if (objType.toObjectType() != null &&
      objType.toObjectType().getIndexType() != null) {
    expectCanAssignTo(t, n, indexType, objType.toObjectType().getIndexType(),
        "restricted index type");
  } else if (objType.isArrayType()) {
    expectNumber(t, n, indexType, "array access");
  } else if (objType.matchesObjectContext()) {
    expectString(t, n, indexType, "property access");
  } else {
    mismatch(t, n, "only arrays or objects can be accessed",
        objType, typeRegistry.createUnionType(ARRAY_TYPE, OBJECT_TYPE));
  }
}
 

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
@Override public Iterable<JSType> getTypeAlternatives(JSType type) {
  if (type.isUnionType()) {
    return ((UnionType) type).getAlternates();
  } else {
    ObjectType objType = type.toObjectType();
    if (objType != null &&
        objType.getConstructor() != null &&
        objType.getConstructor().isInterface()) {
      List<JSType> list = Lists.newArrayList();
      for (FunctionType impl
               : registry.getDirectImplementors(objType)) {
        list.add(impl.getInstanceType());
      }
      return list;
    } else {
      return null;
    }
  }
}
 

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
private void recordPrototypePropUse(
    NodeTraversal t, Node n, Node parent) {
  Preconditions.checkArgument(NodeUtil.isGetProp(n));
  Node instance = n.getFirstChild();
  JSType instanceType = getType(instance);
  JSType boxedType = instanceType.autoboxesTo();
  instanceType = boxedType != null ? boxedType : instanceType;

  // Retrieves the property.
  ObjectType objType = instanceType.toObjectType();
  Preconditions.checkState(objType != null);

  if (!isExtern) {
    // Don't count reference in extern as a use.
    Reference ref = new Reference(n, parent);

    FunctionType constructor = objType.getConstructor();
    if (constructor != null) {
      String propName = n.getLastChild().getString();
      if (!constructor.getPrototype().hasOwnProperty(propName)) {
        recordSuperClassPrototypePropUse(constructor, propName, ref);
      }

      // TODO(user): TightenType can help a whole lot here.
      recordSubclassPrototypePropUse(constructor, propName, ref);
    } else {
      recordUnknownUse(t, n, parent);
    }
  }
}
 

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
private Set<JSType> getTypesToSkipForTypeNonUnion(JSType type) {
  Set<JSType> types = Sets.newHashSet();
  JSType skipType = type;
  while (skipType != null) {
    types.add(skipType);

    ObjectType objSkipType = skipType.toObjectType();
    if (objSkipType != null) {
      skipType = objSkipType.getImplicitPrototype();
    } else {
      break;
    }
  }
  return types;
}
 

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
/**
 * Given a node, get a human-readable name for the type of that node so
 * that will be easy for the programmer to find the original declaration.
 *
 * For example, if SubFoo's property "bar" might have the human-readable
 * name "Foo.prototype.bar".
 *
 * @param n The node.
 * @param dereference If true, the type of the node will be dereferenced
 *     to an Object type, if possible.
 */
String getReadableJSTypeName(Node n, boolean dereference) {
  // If we're analyzing a GETPROP, the property may be inherited by the
  // prototype chain. So climb the prototype chain and find out where
  // the property was originally defined.
  if (n.getType() == Token.GETPROP) {
    ObjectType objectType = getJSType(n.getFirstChild()).dereference();
    if (objectType != null) {
      String propName = n.getLastChild().getString();
      while (objectType != null && !objectType.hasOwnProperty(propName)) {
        objectType = objectType.getImplicitPrototype();
      }

      // Don't show complex function names or anonymous types.
      // Instead, try to get a human-readable type name.
      if (objectType != null &&
          (objectType.getConstructor() != null ||
           objectType.isFunctionPrototypeType())) {
        return objectType.toString() + "." + propName;
      }
    }
  }

  JSType type = getJSType(n);
  if (dereference) {
    ObjectType dereferenced = type.dereference();
    if (dereferenced != null) {
      type = dereferenced;
    }
  }

  String qualifiedName = n.getQualifiedName();
  if (type.isFunctionPrototypeType() ||
      (type.toObjectType() != null &&
       type.toObjectType().getConstructor() != null)) {
    return type.toString();
  } else if (qualifiedName != null) {
    return qualifiedName;
  } else if (type instanceof FunctionType) {
    // Don't show complex function names.
    return "function";
  } else {
    return type.toString();
  }
}