本文整理汇总了Java中org.codehaus.groovy.syntax.Token.newSymbol方法的典型用法代码示例。如果您正苦于以下问题:Java Token.newSymbol方法的具体用法?Java Token.newSymbol怎么用?Java Token.newSymbol使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类org.codehaus.groovy.syntax.Token
的用法示例。
在下文中一共展示了Token.newSymbol方法的12个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: convertInOperatorToTernary
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
private Expression convertInOperatorToTernary(final BinaryExpression bin, final Expression rightExpression, final Expression leftExpression) {
MethodCallExpression call = new MethodCallExpression(
rightExpression,
"isCase",
leftExpression
);
call.setMethodTarget((MethodNode) bin.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET));
call.setSourcePosition(bin);
call.copyNodeMetaData(bin);
TernaryExpression tExp = new TernaryExpression(
new BooleanExpression(
new BinaryExpression(rightExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null))
),
new BinaryExpression(leftExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null)),
call
);
return staticCompilationTransformer.transform(tExp);
}
示例2: transformBinaryExpression
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
private Expression transformBinaryExpression(final BinaryExpression exp) {
final int op = exp.getOperation().getType();
int token = TokenUtil.removeAssignment(op);
if (token == op) {
// no transform needed
return super.transform(exp);
}
BinaryExpression operation = new BinaryExpression(
exp.getLeftExpression(),
Token.newSymbol(token, -1, -1),
exp.getRightExpression()
);
operation.setSourcePosition(exp);
BinaryExpression result = new BinaryExpression(
exp.getLeftExpression(),
Token.newSymbol(EQUAL, -1, -1),
operation
);
result.setSourcePosition(exp);
return result;
}
示例3: createSuperFallback
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
private static Statement createSuperFallback(MethodNode forwarderMethod, ClassNode returnType) {
ArgumentListExpression args = new ArgumentListExpression();
Parameter[] forwarderMethodParameters = forwarderMethod.getParameters();
for (final Parameter forwarderMethodParameter : forwarderMethodParameters) {
args.addExpression(new VariableExpression(forwarderMethodParameter));
}
BinaryExpression instanceOfExpr = new BinaryExpression(new VariableExpression("this"), Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1), new ClassExpression(Traits.GENERATED_PROXY_CLASSNODE));
MethodCallExpression superCall = new MethodCallExpression(
new VariableExpression("super"),
forwarderMethod.getName(),
args
);
superCall.setImplicitThis(false);
CastExpression proxyReceiver = new CastExpression(Traits.GENERATED_PROXY_CLASSNODE, new VariableExpression("this"));
MethodCallExpression getProxy = new MethodCallExpression(proxyReceiver, "getProxyTarget", ArgumentListExpression.EMPTY_ARGUMENTS);
getProxy.setImplicitThis(true);
StaticMethodCallExpression proxyCall = new StaticMethodCallExpression(
ClassHelper.make(InvokerHelper.class),
"invokeMethod",
new ArgumentListExpression(getProxy, new ConstantExpression(forwarderMethod.getName()), new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions()))
);
IfStatement stmt = new IfStatement(
new BooleanExpression(instanceOfExpr),
new ExpressionStatement(new CastExpression(returnType,proxyCall)),
new ExpressionStatement(superCall)
);
return stmt;
}
示例4: createStaticReceiver
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
private TernaryExpression createStaticReceiver(final Expression receiver) {
return new TernaryExpression(
new BooleanExpression(new BinaryExpression(
receiver,
Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1),
new ClassExpression(ClassHelper.CLASS_Type)
)),
receiver,
new MethodCallExpression(createFieldHelperReceiver(), "getClass", ArgumentListExpression.EMPTY_ARGUMENTS)
);
}
示例5: evaluateElvisEqual
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
public void evaluateElvisEqual(BinaryExpression expression) {
Token operation = expression.getOperation();
BinaryExpression elvisAssignmentExpression =
new BinaryExpression(
expression.getLeftExpression(),
Token.newSymbol(Types.EQUAL, operation.getStartLine(), operation.getStartColumn()),
new ElvisOperatorExpression(expression.getLeftExpression(), expression.getRightExpression())
);
this.evaluateEqual(elvisAssignmentExpression, false);
}
示例6: checkReturnType
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
protected ClassNode checkReturnType(final ReturnStatement statement) {
Expression expression = statement.getExpression();
ClassNode type = getType(expression);
if (typeCheckingContext.getEnclosingClosure()!=null) {
return type;
}
// handle instanceof cases
if ((expression instanceof VariableExpression) && hasInferredReturnType(expression)) {
type = expression.getNodeMetaData(StaticTypesMarker.INFERRED_RETURN_TYPE);
}
MethodNode enclosingMethod = typeCheckingContext.getEnclosingMethod();
if (enclosingMethod != null && typeCheckingContext.getEnclosingClosure()==null) {
if (!enclosingMethod.isVoidMethod()
&& !type.equals(void_WRAPPER_TYPE)
&& !type.equals(VOID_TYPE)
&& !checkCompatibleAssignmentTypes(enclosingMethod.getReturnType(), type, null, false)
&& !(isNullConstant(expression))) {
if (!extension.handleIncompatibleReturnType(statement, type)) {
addStaticTypeError("Cannot return value of type " + type.toString(false) + " on method returning type " + enclosingMethod.getReturnType().toString(false), expression);
}
} else if (!enclosingMethod.isVoidMethod()) {
ClassNode previousType = getInferredReturnType(enclosingMethod);
ClassNode inferred = previousType == null ? type : lowestUpperBound(type, previousType);
if (implementsInterfaceOrIsSubclassOf(inferred, enclosingMethod.getReturnType())) {
if (missesGenericsTypes(inferred)) {
DeclarationExpression virtualDecl = new DeclarationExpression(
varX("{target}", enclosingMethod.getReturnType()),
Token.newSymbol(EQUAL, -1, -1),
varX("{source}", type)
);
virtualDecl.setSourcePosition(statement);
virtualDecl.visit(this);
ClassNode newlyInferred = (ClassNode) virtualDecl.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
if (!missesGenericsTypes(newlyInferred)) type = newlyInferred;
} else {
checkTypeGenerics(enclosingMethod.getReturnType(), inferred, expression);
}
return type;
} else {
return enclosingMethod.getReturnType();
}
}
}
return type;
}
示例7: makeToken
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
protected static Token makeToken(int typeCode, AST node) {
return Token.newSymbol(typeCode, node.getLine(), node.getColumn());
}
示例8: addFieldInitialization
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
protected void addFieldInitialization(List list, List staticList, FieldNode fieldNode,
boolean isEnumClassNode, List initStmtsAfterEnumValuesInit, Set explicitStaticPropsInEnum) {
Expression expression = fieldNode.getInitialExpression();
if (expression != null) {
final FieldExpression fe = new FieldExpression(fieldNode);
if (fieldNode.getType().equals(ClassHelper.REFERENCE_TYPE) && ((fieldNode.getModifiers() & Opcodes.ACC_SYNTHETIC) != 0)) {
fe.setUseReferenceDirectly(true);
}
ExpressionStatement statement =
new ExpressionStatement(
new BinaryExpression(
fe,
Token.newSymbol(Types.EQUAL, fieldNode.getLineNumber(), fieldNode.getColumnNumber()),
expression));
if (fieldNode.isStatic()) {
// GROOVY-3311: pre-defined constants added by groovy compiler for numbers/characters should be
// initialized first so that code dependent on it does not see their values as empty
Expression initialValueExpression = fieldNode.getInitialValueExpression();
if (initialValueExpression instanceof ConstantExpression) {
ConstantExpression cexp = (ConstantExpression) initialValueExpression;
cexp = transformToPrimitiveConstantIfPossible(cexp);
if (fieldNode.isFinal() && ClassHelper.isStaticConstantInitializerType(cexp.getType()) && cexp.getType().equals(fieldNode.getType())) {
return; // GROOVY-5150: primitive type constants will be initialized directly
}
staticList.add(0, statement);
} else {
staticList.add(statement);
}
fieldNode.setInitialValueExpression(null); // to avoid double initialization in case of several constructors
/*
* If it is a statement for an explicitly declared static field inside an enum, store its
* reference. For enums, they need to be handled differently as such init statements should
* come after the enum values have been initialized inside <clinit> block. GROOVY-3161.
*/
if (isEnumClassNode && explicitStaticPropsInEnum.contains(fieldNode.getName())) {
initStmtsAfterEnumValuesInit.add(statement);
}
} else {
list.add(statement);
}
}
}
示例9: transformSpreadOnLHS
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
private void transformSpreadOnLHS(BinaryExpression origin) {
PropertyExpression spreadExpression = (PropertyExpression) origin.getLeftExpression();
Expression value = origin.getRightExpression();
WriterController controller = getController();
MethodVisitor mv = controller.getMethodVisitor();
CompileStack compileStack = controller.getCompileStack();
TypeChooser typeChooser = controller.getTypeChooser();
OperandStack operandStack = controller.getOperandStack();
ClassNode classNode = controller.getClassNode();
int counter = labelCounter.incrementAndGet();
Expression receiver = spreadExpression.getObjectExpression();
// create an empty arraylist
VariableExpression result = new VariableExpression(
this.getClass().getSimpleName()+"$spreadresult" + counter,
ARRAYLIST_CLASSNODE
);
ConstructorCallExpression cce = new ConstructorCallExpression(ARRAYLIST_CLASSNODE, ArgumentListExpression.EMPTY_ARGUMENTS);
cce.setNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET, ARRAYLIST_CONSTRUCTOR);
DeclarationExpression declr = new DeclarationExpression(
result,
Token.newSymbol("=", spreadExpression.getLineNumber(), spreadExpression.getColumnNumber()),
cce
);
declr.visit(controller.getAcg());
// if (receiver != null)
receiver.visit(controller.getAcg());
Label ifnull = compileStack.createLocalLabel("ifnull_" + counter);
mv.visitJumpInsn(IFNULL, ifnull);
operandStack.remove(1); // receiver consumed by if()
Label nonull = compileStack.createLocalLabel("nonull_" + counter);
mv.visitLabel(nonull);
ClassNode componentType = StaticTypeCheckingVisitor.inferLoopElementType(typeChooser.resolveType(receiver, classNode));
Parameter iterator = new Parameter(componentType, "for$it$" + counter);
VariableExpression iteratorAsVar = new VariableExpression(iterator);
PropertyExpression pexp = spreadExpression instanceof AttributeExpression ?
new AttributeExpression(iteratorAsVar, spreadExpression.getProperty(), true):
new PropertyExpression(iteratorAsVar, spreadExpression.getProperty(), true);
pexp.setImplicitThis(spreadExpression.isImplicitThis());
pexp.setSourcePosition(spreadExpression);
BinaryExpression assignment = new BinaryExpression(
pexp,
origin.getOperation(),
value
);
MethodCallExpression add = new MethodCallExpression(
result,
"add",
assignment
);
add.setMethodTarget(ARRAYLIST_ADD_METHOD);
// for (e in receiver) { result.add(e?.method(arguments) }
ForStatement stmt = new ForStatement(
iterator,
receiver,
new ExpressionStatement(add)
);
stmt.visit(controller.getAcg());
// else { empty list }
mv.visitLabel(ifnull);
// end of if/else
// return result list
result.visit(controller.getAcg());
}
示例10: testLoop
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
public void testLoop() throws Exception {
ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
classNode.addProperty(new PropertyNode("bar", ACC_PUBLIC, ClassHelper.STRING_TYPE, classNode, null, null, null));
classNode.addProperty(new PropertyNode("result", ACC_PUBLIC, ClassHelper.STRING_TYPE, classNode, null, null, null));
BooleanExpression expression =
new BooleanExpression(
new BinaryExpression(
new FieldExpression(
new FieldNode("bar", ACC_PRIVATE, ClassHelper.STRING_TYPE, classNode, ConstantExpression.NULL)),
Token.newSymbol("==", 0, 0),
new ConstantExpression("abc")));
Statement trueStatement =
new ExpressionStatement(
new BinaryExpression(
new FieldExpression(
new FieldNode("result", ACC_PRIVATE, ClassHelper.STRING_TYPE, classNode, ConstantExpression.NULL)),
Token.newSymbol("=", 0, 0),
new ConstantExpression("worked")));
Statement falseStatement = createPrintlnStatement(new ConstantExpression("false"));
IfStatement statement = new IfStatement(expression, trueStatement, falseStatement);
classNode.addMethod(new MethodNode("ifDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statement));
Class fooClass = loadClass(classNode);
assertTrue("Loaded a new class", fooClass != null);
Object bean = fooClass.newInstance();
assertTrue("Managed to create bean", bean != null);
assertSetProperty(bean, "bar", "abc");
System.out.println("################ Now about to invoke method");
Object[] array = {
};
InvokerHelper.invokeMethod(bean, "ifDemo", array);
System.out.println("################ Done");
assertGetProperty(bean, "result", "worked");
}
示例11: varDeclarationX
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
/**
* Creates a variable definition expression. Where, in the code a
* variable is defined. If could be also initialized.
*
* <strong>AST</strong>
* <pre><code>
* //...after declaring the variables somewhere
* varDeclarationX('johnAge',
* A.NODES.clazz(Integer).build(),
* A.EXPR.constX(23))
* </code></pre>
*
* <strong>Result</strong>
* <pre><code>
* Integer johnAge = 23
* </code></pre>
*
* @param varName name of the declared variable
* @param type type of the declared variable as a {@link ClassNode} instance
* @param defaultValue expression setting the default value of the declared variable
* @return an instance of a {@link DeclarationExpression}
* @since 0.2.4
*/
public static DeclarationExpression varDeclarationX(final String varName, final ClassNode type, final Expression defaultValue) {
return new DeclarationExpression(
A.EXPR.varX(varName, type),
Token.newSymbol(Types.EQUAL, 0, 0),
defaultValue);
}
示例12: binX
import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
/**
* Builds a new {@link BinaryExpression} with the names of the
* variables pointing at both left/right terms in the binary
* expression plus the operator in between. The operator can be
* anyone found in the {@link Types} type
*
* <strong>AST</strong>
* <pre><code>
* //...after declaring the variables somewhere
* boolX('johnAge', Types.PLUS, 'peterAge')
* </code></pre>
*
* <strong>Result</strong>
* <pre><code>
* johnAge + peterAge
* </code></pre>
*
* @param leftVarName name of the variable referenced in the left
* side of the binary expression
* @param operator type of the operator. Use any of the listed in
* {@link Types}
* @param rightVarName name of the variable referenced in the
* right side of the binary expression
* @return a binary expression as a {@link BinaryExpression} instance
* @since 0.2.4
*/
public static BinaryExpression binX(final String leftVarName, final int operator, final String rightVarName) {
return new BinaryExpression(A.EXPR.varX(leftVarName),
Token.newSymbol(operator, 0, 0),
A.EXPR.varX(rightVarName));
}