Java Name.getIdentifier方法代码示例

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
private Node transformXmlRef(Node pn, XmlRef node, int memberTypeFlags) {
    if ((memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0)
        decompiler.addToken(Token.XMLATTR);
    Name namespace = node.getNamespace();
    String ns = namespace != null ? namespace.getIdentifier() : null;
    if (ns != null) {
        decompiler.addName(ns);
        decompiler.addToken(Token.COLONCOLON);
    }
    if (node instanceof XmlPropRef) {
        String name = ((XmlPropRef)node).getPropName().getIdentifier();
        decompiler.addName(name);
        return createPropertyGet(pn, ns, name, memberTypeFlags);
    } else {
        decompiler.addToken(Token.LB);
        Node expr = transform(((XmlElemRef)node).getExpression());
        decompiler.addToken(Token.RB);
        return createElementGet(pn, ns, expr, memberTypeFlags);
    }
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
/**
 * Gets a Java-compatible "informative" name for the the ScriptOrFnNode
 */
String cleanName(final ScriptNode n)
{
  String result = "";
  if (n instanceof FunctionNode) {
    Name name = ((FunctionNode) n).getFunctionName();
    if (name == null) {
      result = "anonymous";
    } else {
      result = name.getIdentifier();
    }
  } else {
    result = "script";
  }
  return result;
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
/**
 * for an expression that consists of a simple reference to a variable, we create an ITerm
 * for that expression, find the unique representative for the referenced variable, and
 * generate a constraint that equates these.
 */
private ITypeTerm processVariableReference(Name name) {
	ITypeTerm expTerm = findOrCreateExpressionTerm(name);
	if (!ConstraintGenUtil.isGlobal(name)){ // no need for NameDeclarationTerm for global variables
		Name declaration = ConstraintGenUtil.findDecl(name);
		ITypeTerm nameTerm = findOrCreateNameDeclarationTerm(declaration);
		addTypeEqualityConstraint(expTerm, nameTerm, name.getLineno(), null);
	} else {
		String identifier = name.getIdentifier();
		if (identifier.equals("undefined")){
			addTypeEqualityConstraint(new TypeParamTerm(name), findOrCreateExpressionTerm(name), name.getLineno(), null);
		} else {
			ITypeTerm globalTerm = findOrCreateGlobalDeclarationTerm(name, jsEnv);
			addTypeEqualityConstraint(globalTerm, expTerm, name.getLineno(), null);
			createConstraintsForGlobalFunction(name);
		}
	}
	return expTerm;
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
/**
 * Find or create a term representing an expression consisting of a variable name
 */
public NameDeclarationTerm findOrCreateNameDeclarationTerm(final Name name){
    Name name2 = ConstraintGenUtil.findDecl(name);
    if (name2 == null) {
        throw new Error("no declaration found for " + name.getIdentifier());
    }
    if (!nameTerms.containsKey(name2)){
        nameTerms.put(name2, new NameDeclarationTerm(name2));
    }
    return nameTerms.get(name2);
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
/**
 * Create constraints for parameterized external functions such as Array<T>
 */
private void createConstraintsForGlobalFunction(Name name) {
	ITypeTerm term = findOrCreateExpressionTerm(name);
	String functionName = name.getIdentifier();
	Type type = jsEnv.get(functionName);
	if (type == null){
		error("reference to unknown global: " + name.getIdentifier(), name);
		return;
	}
	ITypeTerm typeParamTerm = new TypeParamTerm(name);
	if (ConstraintGenUtil.isParameterized(type)){
		generateConstraintsForType(name, typeParamTerm, term, type);
	}
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
@Override
public boolean visit(AstNode node) {
    if (node instanceof Name) {
        Name name = (Name) node;
        if (!name.isLocalName()) {
            String id = name.getIdentifier();
            usages.put(id, getUsage(id) + 1);
        }
    }
    return true;
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
/**
 * Extract the variable from the Rhino node and add to the CodeBlock
 * 
 * @param node AstNode node from which to extract the variable
 * @param block code block to add the variable too
 * @param offset position of the variable in code
 * @param initializer node associated with variable
 */
private JavaScriptVariableDeclaration extractVariableFromNode(AstNode node,
		CodeBlock block, int offset, AstNode initializer) {
	JavaScriptVariableDeclaration dec = null;
	// check that the caret position is below the dot before looking for
	// the variable
	if (node != null) {

		switch (node.getType()) {
			case Token.NAME:
				Name name = (Name) node;
				dec = new JavaScriptVariableDeclaration(name
						.getIdentifier(), offset, provider, block);
				dec.setStartOffset(name.getAbsolutePosition());
				dec.setEndOffset(name.getAbsolutePosition() + name.getLength());
				if (initializer != null
						&& initializer.getType() == Token.CALL) {
					// set the type node later for functions as these
					// sometimes cannot be resolved until
					// after the entire document is parsed
					ProcessFunctionType func = new ProcessFunctionType();
					func.dec = dec;
					func.typeNode = initializer;
					functions.add(func);
				}
				if (initializer == null
						|| JavaScriptHelper.canResolveVariable(name,
								initializer)) {
					block.addVariable(dec);
				}
				break;
			default:
				Logger.log("... Unknown var target type: "
						+ node.getClass());
				break;
		}
	}

	return dec;
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
public NameDeclarationTerm(Name name) {
super(name);
this.identifier = name.getIdentifier();
this.type = new AnyType();
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
/**
 * assignment to the "prototype" property
 */
private void processAssignToPrototype(Assignment a, AstNode left, AstNode right, ITypeTerm expTerm) throws Error {
	PropertyGet pg = (PropertyGet)left;
	AstNode base = pg.getTarget();
	ITypeTerm pgTerm = findOrCreateExpressionTerm(pg);
	if (base instanceof Name){
		Name name = (Name)base;
		if (!validRHSForAssignToPrototype(right)) {
			error(
					"expression "
							+ right.toSource()
							+ " cannot be assigned to a constructor prototype (line "
							+ right.getLineno() + ")", a);
		}
		// can only write to prototype immediately after declaration of
		// constructor of the same name
		AstNode parent = a.getParent();
		if (!(parent instanceof ExpressionStatement)) {
			error(
					"assignment to prototype property not allowed here (line "
							+ a.getLineno() + ")", a);
			return;
		}
		Node prev = getPredecessorNode(parent);
		if (!(prev instanceof FunctionNode)) {
			error(
					"assignment to prototype property only allowed after constructor declaration (line "
							+ a.getLineno() + ")", a);
			return;
		}
		FunctionNode fn = (FunctionNode) prev;
		String functionName = fn.getName();
		String identifier = name.getIdentifier();
		if (!functionName.equals(identifier)) {
			error(
					"can only assign to prototype of function "
							+ functionName + " here (line " + a.getLineno()
							+ ")", a);
			return;
		}
		ITypeTerm baseTerm = findOrCreateExpressionTerm(base); // make term for expression
		ITypeTerm nameTerm = findOrCreateNameDeclarationTerm(name); // find unique representative for referenced Name
		addTypeEqualityConstraint(baseTerm, nameTerm, a.getLineno(), null); // equate them
		ITypeTerm protoTerm = findOrCreateProtoTerm(baseTerm, pg.getLineno());
		ITypeTerm rightTerm = processExpression(right);
		addTypeEqualityConstraint(pgTerm, protoTerm, a.getLineno(), null);
		addTypeEqualityConstraint(rightTerm, protoTerm, a.getLineno(), null);
		addTypeEqualityConstraint(expTerm, protoTerm, a.getLineno(), null);
	} else {
		error("processAssignToPrototype: unsupported case for receiver expression: " + base.getClass().getName(), base);
	}
}
 

import org.mozilla.javascript.ast.Name; //导入方法依赖的package包/类
private void checkForValidProtoPropAssign(Assignment a, PropertyGet pg,
		int assignLineNo, PropertyGet basePG) {
	AstNode baseTarget = basePG.getTarget();
	if (!(baseTarget instanceof Name)) {
		error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
		return;
	}
	Name baseName = (Name) baseTarget;
	AstNode parent = a.getParent();
	if (!(parent instanceof ExpressionStatement)) {
		error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
		return;
	}
	Node prev = getPredecessorNode(parent);
	if (prev instanceof FunctionNode) {
		FunctionNode fn = (FunctionNode) prev;
		String functionName = fn.getName();
		String identifier = baseName.getIdentifier();
		if (!functionName.equals(identifier)) {
			error("can only assign to prototype of function " + functionName + " here (line " + assignLineNo + ")", a);
			return;
		}

	} else if (prev instanceof ExpressionStatement) {
		// it needs to be an assignment either to C.prototype or C.prototype.foo
		// TODO clean up this gross code
		AstNode expression = ((ExpressionStatement)prev).getExpression();
		if (!(expression instanceof Assignment)) {
			error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
			return;
		}
		Assignment prevAssign = (Assignment) expression;
		AstNode prevLeft = prevAssign.getLeft();
		if (!(prevLeft instanceof PropertyGet)) {
			error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
			return;
		}
		PropertyGet prevPG = (PropertyGet) prevLeft;
		AstNode prevPGTarget = prevPG.getTarget();
		if (prevPG.getProperty().getIdentifier().equals("prototype")) {
			checkForSameName(assignLineNo, baseName, prevPGTarget);
		} else if (prevPGTarget instanceof PropertyGet) {
			PropertyGet prevPGBasePG = (PropertyGet) prevPGTarget;
			if (!prevPGBasePG.getProperty().getIdentifier().equals("prototype")) {
				error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
				return;
			}
			checkForSameName(assignLineNo, baseName, prevPGBasePG.getTarget());
		} else {
			error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
			return;
		}
	} else {
		error("assignment to property of prototype not valid (line " + assignLineNo + ")", a);
		return;
	}
}