public ClassNode getType() { return expression.getType(); } }
@Override public ClassNode getType() { return expression.getType(); } }
public ClassNode getType() { return expression.getType(); } }
public ClassNode getType() { return expression.getType(); }
public ClassNode getType() { return expression.getType(); }
public ClassNode getType() { return expression.getType(); }
private static List<ClassNode> getTypeList(ListExpression listExpression) { List<ClassNode> list = new ArrayList<ClassNode>(); for (Expression itemExpr : listExpression.getExpressions()) { if (itemExpr instanceof ClassExpression) { ClassNode cn = itemExpr.getType(); if (cn != null) list.add(cn); } } return list; }
@Deprecated public List<ClassNode> getClassList(AnnotationNode anno, String name) { List<ClassNode> list = new ArrayList<ClassNode>(); Expression expr = anno.getMember(name); if (expr instanceof ListExpression) { final ListExpression listExpression = (ListExpression) expr; list = getTypeList(listExpression); } else if (expr instanceof ClassExpression) { ClassNode cn = expr.getType(); if (cn != null) list.add(cn); } return list; }
public static Expression getVariableType(BinaryExpression assignment) { ClassNode type = assignment.getLeftExpression().getType(); return type == null || type == ClassHelper.DYNAMIC_TYPE ? ConstantExpression.NULL : new ClassExpression(type); }
public FieldNode(String name, int modifiers, ClassNode type, ClassNode owner, Expression initialValueExpression) { this.name = name; this.modifiers = modifiers; this.type = type; if (this.type == ClassHelper.DYNAMIC_TYPE && initialValueExpression != null) this.setType(initialValueExpression.getType()); this.setType(type); this.originType = type; this.owner = owner; this.initialValueExpression = initialValueExpression; }
private void checkConstantTypeIfNotMethodNameOrProperty(final Expression expr) { if (expr instanceof ConstantExpression) { if (!"java.lang.String".equals(expr.getType().getName())) { expr.visit(this); } } else { expr.visit(this); } }
public void visitPropertyExpression(final PropertyExpression expression) { assertExpressionAuthorized(expression); Expression receiver = expression.getObjectExpression(); final String typeName = receiver.getType().getName(); if (receiversWhiteList != null && !receiversWhiteList.contains(typeName)) { throw new SecurityException("Property access not allowed on [" + typeName + "]"); } else if (receiversBlackList != null && receiversBlackList.contains(typeName)) { throw new SecurityException("Property access not allowed on [" + typeName + "]"); } receiver.visit(this); final Expression property = expression.getProperty(); checkConstantTypeIfNotMethodNameOrProperty(property); }
protected void visitEnumExpression(String attrName, PropertyExpression propExpr, ClassNode attrType) { if (!propExpr.getObjectExpression().getType().isDerivedFrom(attrType)) { addError("Attribute '" + attrName + "' should have type '" + attrType.getName() + "' (Enum), but found " + propExpr.getObjectExpression().getType().getName(), propExpr); } }
private static boolean checkIsConditionBlock(MethodCallExpression methodCallExpr) { ClassNode targetType = methodCallExpr.getObjectExpression().getType(); String methodName = methodCallExpr.getMethodAsString(); List<MethodNode> methods = targetType.getMethods(methodName); for (MethodNode method : methods) { for (AnnotationNode annotation : method.getAnnotations()) { if (annotation.getClassNode().getName().equals(ConditionBlock.class.getName())) return true; } } return false; } }
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(); }
private static boolean isUndefinedMarkerList(ListExpression listExpression) { if (listExpression.getExpressions().size() != 1) return false; Expression itemExpr = listExpression.getExpression(0); if (itemExpr == null) return false; if (itemExpr instanceof ConstantExpression) { Object value = ((ConstantExpression) itemExpr).getValue(); if (value instanceof String && isUndefined((String)value)) return true; } else if (itemExpr instanceof ClassExpression && isUndefined(itemExpr.getType())) { return true; } return false; }
private void changeBaseScriptTypeFromPackageOrImport(final SourceUnit source, final AnnotatedNode parent, final AnnotationNode node) { Expression value = node.getMember("value"); if (!(value instanceof ClassExpression)) { addError("Annotation " + MY_TYPE_NAME + " member 'value' should be a class literal.", value); return; } List<ClassNode> classes = source.getAST().getClasses(); for (ClassNode classNode : classes) { if (classNode.isScriptBody()) { changeBaseScriptType(parent, classNode, value.getType()); } } }
public void visitDeclarationExpression(DeclarationExpression expression) { //visitNode(expression); is visited afterwards in BinaryExpression. Because //super.visitDeclarationExpression calls visitBinaryExpression visitType(expression.getLeftExpression().getType()); super.visitDeclarationExpression(expression); }
@Override public void visitAttributeExpression(final AttributeExpression expression) { super.visitAttributeExpression(expression); if (!existsProperty(expression, true) && !extension.handleUnresolvedAttribute(expression)) { Expression objectExpression = expression.getObjectExpression(); addStaticTypeError("No such property: " + expression.getPropertyAsString() + " for class: " + findCurrentInstanceOfClass(objectExpression, objectExpression.getType()), expression); } }
public void loadWrapper(Expression argument) { MethodVisitor mv = controller.getMethodVisitor(); ClassNode goalClass = argument.getType(); visitClassExpression(new ClassExpression(goalClass)); if (goalClass.isDerivedFromGroovyObject()) { createGroovyObjectWrapperMethod.call(mv); } else { createPojoWrapperMethod.call(mv); } controller.getOperandStack().remove(1); }