本文整理汇总了Java中org.codehaus.groovy.ast.ConstructorNode.getParameters方法的典型用法代码示例。如果您正苦于以下问题:Java ConstructorNode.getParameters方法的具体用法?Java ConstructorNode.getParameters怎么用?Java ConstructorNode.getParameters使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类org.codehaus.groovy.ast.ConstructorNode
的用法示例。
在下文中一共展示了ConstructorNode.getParameters方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: adjustConstructorAndFields
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private void adjustConstructorAndFields(int skipIndex, ClassNode type) {
List<ConstructorNode> constructors = type.getDeclaredConstructors();
if (constructors.size() == 1) {
ConstructorNode constructor = constructors.get(0);
Parameter[] params = constructor.getParameters();
Parameter[] newParams = new Parameter[params.length - 1];
int to = 0;
for (int from = 0; from < params.length; from++) {
if (from != skipIndex) {
newParams[to++] = params[from];
}
}
type.removeConstructor(constructor);
// code doesn't mention the removed param at this point, okay to leave as is
type.addConstructor(constructor.getModifiers(), newParams, constructor.getExceptions(), constructor.getCode());
type.removeField(variableName);
}
}
示例2: addImplicitConstructors
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
/**
* Add map and no-arg constructor or mirror those of the superclass (i.e. base enum).
*/
private static void addImplicitConstructors(ClassNode enumClass, boolean aic) {
if (aic) {
ClassNode sn = enumClass.getSuperClass();
List<ConstructorNode> sctors = new ArrayList<ConstructorNode>(sn.getDeclaredConstructors());
if (sctors.isEmpty()) {
addMapConstructors(enumClass, false);
} else {
for (ConstructorNode constructorNode : sctors) {
ConstructorNode init = new ConstructorNode(Opcodes.ACC_PUBLIC, constructorNode.getParameters(), ClassNode.EMPTY_ARRAY, new BlockStatement());
enumClass.addConstructor(init);
}
}
} else {
addMapConstructors(enumClass, false);
}
}
示例3: getMatchingConstructor
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private static ConstructorNode getMatchingConstructor(List<ConstructorNode> constructors, List<Expression> argumentList) {
ConstructorNode lastMatch = null;
for (int i=0; i<constructors.size(); i++) {
ConstructorNode cn = constructors.get(i);
Parameter[] params = cn.getParameters();
// if number of parameters does not match we have no match
if (argumentList.size()!=params.length) continue;
if (lastMatch==null) {
lastMatch = cn;
} else {
// we already had a match so we don't make a direct call at all
return null;
}
}
return lastMatch;
}
示例4: addConstructorUnlessAlreadyExisting
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private void addConstructorUnlessAlreadyExisting(ClassNode classNode, ConstructorNode consNode, boolean copyConstructorAnnotations, boolean copyParameterAnnotations) {
Parameter[] origParams = consNode.getParameters();
if (consNode.isPrivate()) return;
Parameter[] params = new Parameter[origParams.length];
Map<String, ClassNode> genericsSpec = createGenericsSpec(classNode);
extractSuperClassGenerics(classNode, classNode.getSuperClass(), genericsSpec);
List<Expression> theArgs = buildParams(origParams, params, genericsSpec, copyParameterAnnotations);
if (isExisting(classNode, params)) return;
ConstructorNode added = classNode.addConstructor(consNode.getModifiers(), params, consNode.getExceptions(), block(ctorSuperS(args(theArgs))));
if (copyConstructorAnnotations) {
added.addAnnotations(copyAnnotatedNodeAnnotations(consNode, MY_TYPE_NAME));
}
}
示例5: hasNoargConstructor
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private static boolean hasNoargConstructor(ClassNode cNode) {
List<ConstructorNode> constructors = cNode.getDeclaredConstructors();
for (ConstructorNode next : constructors) {
if (next.getParameters().length == 0) {
return true;
}
}
return false;
}
示例6: visitConstructor
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
@Override
public void visitConstructor(final ConstructorNode node) {
if (shouldSkipMethodNode(node)) {
// method has already been visited by a static type checking visitor
return;
}
for (Parameter parameter : node.getParameters()) {
if (parameter.getInitialExpression()!=null) {
parameter.getInitialExpression().visit(this);
}
}
super.visitConstructor(node);
}
示例7: doAddConstructor
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private static void doAddConstructor(final ClassNode cNode, final ConstructorNode constructorNode) {
cNode.addConstructor(constructorNode);
// GROOVY-5814: Immutable is not compatible with @CompileStatic
Parameter argsParam = null;
for (Parameter p : constructorNode.getParameters()) {
if ("args".equals(p.getName())) {
argsParam = p;
break;
}
}
if (argsParam!=null) {
final Parameter arg = argsParam;
ClassCodeVisitorSupport variableExpressionFix = new ClassCodeVisitorSupport() {
@Override
protected SourceUnit getSourceUnit() {
return cNode.getModule().getContext();
}
@Override
public void visitVariableExpression(final VariableExpression expression) {
super.visitVariableExpression(expression);
if ("args".equals(expression.getName())) {
expression.setAccessedVariable(arg);
}
}
};
variableExpressionFix.visitConstructor(constructorNode);
}
}
示例8: writeAICCall
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
protected boolean writeAICCall(ConstructorCallExpression call) {
if (!call.isUsingAnonymousInnerClass()) return false;
ConstructorNode cn = call.getType().getDeclaredConstructors().get(0);
OperandStack os = controller.getOperandStack();
String ownerDescriptor = prepareConstructorCall(cn);
List<Expression> args = makeArgumentList(call.getArguments()).getExpressions();
Parameter[] params = cn.getParameters();
// if a this appears as parameter here, then it should be
// not static, unless we are in a static method. But since
// ACG#visitVariableExpression does the opposite for this case, we
// push here an explicit this. This should not have any negative effect
// sine visiting a method call or property with implicit this will push
// a new value for this again.
controller.getCompileStack().pushImplicitThis(true);
for (int i=0; i<params.length; i++) {
Parameter p = params[i];
Expression arg = args.get(i);
if (arg instanceof VariableExpression) {
VariableExpression var = (VariableExpression) arg;
loadVariableWithReference(var);
} else {
arg.visit(controller.getAcg());
}
os.doGroovyCast(p.getType());
}
controller.getCompileStack().popImplicitThis();
finnishConstructorCall(cn, ownerDescriptor, args.size());
return true;
}
示例9: selectAccessibleConstructorFromSuper
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private static Parameter[] selectAccessibleConstructorFromSuper(ConstructorNode node) {
ClassNode type = node.getDeclaringClass();
ClassNode superType = type.getUnresolvedSuperClass();
Parameter[] bestMatch = null;
for (ConstructorNode c : superType.getDeclaredConstructors()) {
// Only look at things we can actually call
if (!c.isPublic() && !c.isProtected()) continue;
Parameter[] parameters = c.getParameters();
// workaround for GROOVY-5859: remove generic type info
Parameter[] copy = new Parameter[parameters.length];
for (int i = 0; i < copy.length; i++) {
Parameter orig = parameters[i];
copy[i] = new Parameter(orig.getOriginType().getPlainNodeReference(), orig.getName());
}
if (noExceptionToAvoid(node,c)) return copy;
if (bestMatch==null) bestMatch = copy;
}
if (bestMatch!=null) return bestMatch;
// fall back for parameterless constructor
if (superType.isPrimaryClassNode()) {
return Parameter.EMPTY_ARRAY;
}
return null;
}
示例10: getConstructorArgumentType
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private static ClassNode getConstructorArgumentType(Expression arg, ConstructorNode node) {
if (!(arg instanceof VariableExpression)) return arg.getType();
VariableExpression vexp = (VariableExpression) arg;
String name = vexp.getName();
for (Parameter param : node.getParameters()) {
if (param.getName().equals(name)) {
return param.getType();
}
}
return vexp.getType();
}
示例11: createCloneCopyConstructor
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
private static void createCloneCopyConstructor(ClassNode cNode, List<FieldNode> list, List<String> excludes) {
if (cNode.getDeclaredConstructors().isEmpty()) {
// add no-arg constructor
BlockStatement noArgBody = new BlockStatement();
noArgBody.addStatement(EmptyStatement.INSTANCE);
cNode.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, noArgBody);
}
boolean hasThisCons = false;
for (ConstructorNode consNode : cNode.getDeclaredConstructors()) {
Parameter[] parameters = consNode.getParameters();
if (parameters.length == 1 && parameters[0].getType().equals(cNode)) {
hasThisCons = true;
}
}
if (!hasThisCons) {
BlockStatement initBody = new BlockStatement();
Parameter initParam = param(GenericsUtils.nonGeneric(cNode), "other");
final Expression other = varX(initParam);
boolean hasParent = cNode.getSuperClass() != ClassHelper.OBJECT_TYPE;
if (hasParent) {
initBody.addStatement(stmt(ctorX(ClassNode.SUPER, other)));
}
for (FieldNode fieldNode : list) {
String name = fieldNode.getName();
if (excludes != null && excludes.contains(name)) continue;
ClassNode fieldType = fieldNode.getType();
Expression direct = propX(other, name);
Expression to = propX(varX("this"), name);
Statement assignDirect = assignS(to, direct);
Statement assignCloned = assignS(to, castX(fieldType, callCloneDirectX(direct)));
Statement assignClonedDynamic = assignS(to, castX(fieldType, callCloneDynamicX(direct)));
if (isCloneableType(fieldType)) {
initBody.addStatement(assignCloned);
} else if (!possiblyCloneable(fieldType)) {
initBody.addStatement(assignDirect);
} else {
initBody.addStatement(ifElseS(isInstanceOfX(direct, CLONEABLE_TYPE), assignClonedDynamic, assignDirect));
}
}
cNode.addConstructor(ACC_PROTECTED, params(initParam), ClassNode.EMPTY_ARRAY, initBody);
}
ClassNode[] exceptions = {make(CloneNotSupportedException.class)};
cNode.addMethod("clone", ACC_PUBLIC, GenericsUtils.nonGeneric(cNode), Parameter.EMPTY_ARRAY, exceptions, block(stmt(ctorX(cNode, args(varX("this"))))));
}
示例12: transformConstructorCall
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
Expression transformConstructorCall(final ConstructorCallExpression expr) {
ConstructorNode node = (ConstructorNode) expr.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
if (node == null) return expr;
Parameter[] params = node.getParameters();
if ((params.length == 1 || params.length == 2) // 2 is for inner class case
&& StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(params[params.length - 1].getType(), ClassHelper.MAP_TYPE)
&& node.getCode() == StaticTypeCheckingVisitor.GENERATED_EMPTY_STATEMENT) {
Expression arguments = expr.getArguments();
if (arguments instanceof TupleExpression) {
TupleExpression tupleExpression = (TupleExpression) arguments;
List<Expression> expressions = tupleExpression.getExpressions();
if (expressions.size() == 1 || expressions.size() == 2) { // 2 = inner class case
Expression expression = expressions.get(expressions.size() - 1);
if (expression instanceof MapExpression) {
MapExpression map = (MapExpression) expression;
// check that the node doesn't belong to the list of declared constructors
ClassNode declaringClass = node.getDeclaringClass();
for (ConstructorNode constructorNode : declaringClass.getDeclaredConstructors()) {
if (constructorNode == node) {
return staticCompilationTransformer.superTransform(expr);
}
}
// replace call to <init>(Map) or <init>(this, Map)
// with a call to <init>() or <init>(this) + appropriate setters
// for example, foo(x:1, y:2) is replaced with:
// { def tmp = new Foo(); tmp.x = 1; tmp.y = 2; return tmp }()
MapStyleConstructorCall result = new MapStyleConstructorCall(
staticCompilationTransformer,
declaringClass,
map,
expr
);
return result;
}
}
}
}
return staticCompilationTransformer.superTransform(expr);
}
示例13: writeClosure
import org.codehaus.groovy.ast.ConstructorNode; //导入方法依赖的package包/类
public void writeClosure(ClosureExpression expression) {
CompileStack compileStack = controller.getCompileStack();
MethodVisitor mv = controller.getMethodVisitor();
ClassNode classNode = controller.getClassNode();
AsmClassGenerator acg = controller.getAcg();
// generate closure as public class to make sure it can be properly invoked by classes of the
// Groovy runtime without circumventing JVM access checks (see CachedMethod for example).
int mods = ACC_PUBLIC;
if (classNode.isInterface()) {
mods |= ACC_STATIC;
}
ClassNode closureClass = getOrAddClosureClass(expression, mods);
String closureClassinternalName = BytecodeHelper.getClassInternalName(closureClass);
List constructors = closureClass.getDeclaredConstructors();
ConstructorNode node = (ConstructorNode) constructors.get(0);
Parameter[] localVariableParams = node.getParameters();
mv.visitTypeInsn(NEW, closureClassinternalName);
mv.visitInsn(DUP);
if (controller.isStaticMethod() || compileStack.isInSpecialConstructorCall()) {
(new ClassExpression(classNode)).visit(acg);
(new ClassExpression(controller.getOutermostClass())).visit(acg);
} else {
mv.visitVarInsn(ALOAD, 0);
controller.getOperandStack().push(ClassHelper.OBJECT_TYPE);
loadThis();
}
// now let's load the various parameters we're passing
// we start at index 2 because the first variable we pass
// is the owner instance and at this point it is already
// on the stack
for (int i = 2; i < localVariableParams.length; i++) {
Parameter param = localVariableParams[i];
String name = param.getName();
loadReference(name, controller);
if (param.getNodeMetaData(ClosureWriter.UseExistingReference.class)==null) {
param.setNodeMetaData(ClosureWriter.UseExistingReference.class,Boolean.TRUE);
}
}
// we may need to pass in some other constructors
//cv.visitMethodInsn(INVOKESPECIAL, innerClassinternalName, "<init>", prototype + ")V");
mv.visitMethodInsn(INVOKESPECIAL, closureClassinternalName, "<init>", BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, localVariableParams), false);
controller.getOperandStack().replace(ClassHelper.CLOSURE_TYPE, localVariableParams.length);
}