Examples with FormalParameter org.checkerframework.dataflow.expression.FormalParameter used on opensource projects

Example 1 with FormalParameter

use of org.checkerframework.dataflow.expression.FormalParameter in project checker-framework by typetools.

the class StringToJavaExpression method atTypeDecl.

/**
 * Parses a string to a {@link JavaExpression} as if it were written at {@code typeElement}.
 *
 * @param expression a Java expression to parse
 * @param typeElement type element at which {@code expression} is parsed
 * @param checker checker used to get the {@link
 *     javax.annotation.processing.ProcessingEnvironment} and current {@link
 *     com.sun.source.tree.CompilationUnitTree}
 * @return a {@code JavaExpression} for {@code expression}
 * @throws JavaExpressionParseException if {@code expression} cannot be parsed
 */
static JavaExpression atTypeDecl(String expression, TypeElement typeElement, SourceChecker checker) throws JavaExpressionParseException {
    ThisReference thisReference = new ThisReference(typeElement.asType());
    List<FormalParameter> parameters = null;
    return JavaExpressionParseUtil.parse(expression, typeElement.asType(), thisReference, parameters, null, checker.getPathToCompilationUnit(), checker.getProcessingEnvironment());
}

Example 2 with FormalParameter

use of org.checkerframework.dataflow.expression.FormalParameter in project checker-framework by typetools.

the class StringToJavaExpression method atLambdaParameter.

/**
 * Parses a string as if it were written at one of the parameters of {@code lambdaTree}.
 * Parameters of the lambda are expressed as {@link LocalVariable}s.
 *
 * @param expression a Java expression to parse
 * @param lambdaTree the lambda tree
 * @param parentPath path to the parent of {@code lambdaTree}; required because the expression can
 *     reference final local variables of the enclosing method
 * @param checker checker used to get the {@link
 *     javax.annotation.processing.ProcessingEnvironment} and current {@link
 *     com.sun.source.tree.CompilationUnitTree}
 * @return a {@code JavaExpression} for {@code expression}
 * @throws JavaExpressionParseException if {@code expression} cannot be parsed
 */
static JavaExpression atLambdaParameter(String expression, LambdaExpressionTree lambdaTree, TreePath parentPath, SourceChecker checker) throws JavaExpressionParseException {
    TypeMirror enclosingType = TreeUtils.typeOf(TreePathUtil.enclosingClass(parentPath));
    JavaExpression receiver = JavaExpression.getPseudoReceiver(parentPath, enclosingType);
    // If receiver isn't a ThisReference, then the lambda is in a static context and "this"
    // cannot be referenced in the expression.
    ThisReference thisReference = receiver instanceof ThisReference ? (ThisReference) receiver : null;
    List<JavaExpression> paramsAsLocals = new ArrayList<>(lambdaTree.getParameters().size());
    List<FormalParameter> parameters = new ArrayList<>(lambdaTree.getParameters().size());
    int oneBasedIndex = 1;
    for (VariableTree arg : lambdaTree.getParameters()) {
        LocalVariable param = (LocalVariable) JavaExpression.fromVariableTree(arg);
        paramsAsLocals.add(param);
        parameters.add(new FormalParameter(oneBasedIndex, (VariableElement) param.getElement()));
        oneBasedIndex++;
    }
    JavaExpression javaExpr = JavaExpressionParseUtil.parse(expression, enclosingType, thisReference, parameters, parentPath, checker.getPathToCompilationUnit(), checker.getProcessingEnvironment());
    return ViewpointAdaptJavaExpression.viewpointAdapt(javaExpr, paramsAsLocals);
}

Example 3 with FormalParameter

use of org.checkerframework.dataflow.expression.FormalParameter in project checker-framework by typetools.

the class StringToJavaExpression method atFieldDecl.

/**
 * Parses a string to a {@link JavaExpression} as if it were written at {@code fieldElement}.
 *
 * @param expression a Java expression to parse
 * @param fieldElement variable element at which {@code expression} is parsed
 * @param checker checker used to get the {@link
 *     javax.annotation.processing.ProcessingEnvironment} and current {@link
 *     com.sun.source.tree.CompilationUnitTree}
 * @return a {@code JavaExpression} for {@code expression}
 * @throws JavaExpressionParseException if {@code expression} cannot be parsed
 */
static JavaExpression atFieldDecl(String expression, VariableElement fieldElement, SourceChecker checker) throws JavaExpressionParseException {
    TypeMirror enclosingType = ElementUtils.enclosingTypeElement(fieldElement).asType();
    ThisReference thisReference;
    if (ElementUtils.isStatic(fieldElement)) {
        // Can't use "this" on a static fieldElement
        thisReference = null;
    } else {
        thisReference = new ThisReference(enclosingType);
    }
    List<FormalParameter> parameters = null;
    return JavaExpressionParseUtil.parse(expression, enclosingType, thisReference, parameters, null, checker.getPathToCompilationUnit(), checker.getProcessingEnvironment());
}

Example 4 with FormalParameter

use of org.checkerframework.dataflow.expression.FormalParameter in project checker-framework by typetools.

the class StringToJavaExpression method atPath.

/**
 * Parses a string as if it were written at {@code localVarPath}.
 *
 * @param expression a Java expression to parse
 * @param localVarPath location at which {@code expression} is parsed
 * @param checker checker used to get the {@link
 *     javax.annotation.processing.ProcessingEnvironment} and current {@link
 *     com.sun.source.tree.CompilationUnitTree}
 * @return a {@code JavaExpression} for {@code expression}
 * @throws JavaExpressionParseException if {@code expression} cannot be parsed
 */
static JavaExpression atPath(String expression, TreePath localVarPath, SourceChecker checker) throws JavaExpressionParseException {
    TypeMirror enclosingType = TreeUtils.typeOf(TreePathUtil.enclosingClass(localVarPath));
    ThisReference thisReference = TreePathUtil.isTreeInStaticScope(localVarPath) ? null : new ThisReference(enclosingType);
    MethodTree methodTree = TreePathUtil.enclosingMethod(localVarPath);
    if (methodTree == null) {
        return JavaExpressionParseUtil.parse(expression, enclosingType, thisReference, null, localVarPath, checker.getPathToCompilationUnit(), checker.getProcessingEnvironment());
    }
    ExecutableElement methodEle = TreeUtils.elementFromDeclaration(methodTree);
    List<FormalParameter> parameters = JavaExpression.getFormalParameters(methodEle);
    JavaExpression javaExpr = JavaExpressionParseUtil.parse(expression, enclosingType, thisReference, parameters, localVarPath, checker.getPathToCompilationUnit(), checker.getProcessingEnvironment());
    List<JavaExpression> paramsAsLocals = JavaExpression.getParametersAsLocalVariables(methodEle);
    return ViewpointAdaptJavaExpression.viewpointAdapt(javaExpr, paramsAsLocals);
}

Example 5 with FormalParameter

use of org.checkerframework.dataflow.expression.FormalParameter in project checker-framework by typetools.

the class StringToJavaExpression method atMethodDecl.

/**
 * Parses a string to a {@link JavaExpression} as if it were written at {@code method}. The
 * returned {@code JavaExpression} uses {@link FormalParameter}s to represent parameters. Use
 * {@link #atMethodBody(String, MethodTree, SourceChecker)} if parameters should be {@link
 * LocalVariable}s instead.
 *
 * @param expression a Java expression to parse
 * @param method method element at which {@code expression} is parsed
 * @param checker checker used to get the {@link
 *     javax.annotation.processing.ProcessingEnvironment} and current {@link
 *     com.sun.source.tree.CompilationUnitTree}
 * @return a {@code JavaExpression} for {@code expression}
 * @throws JavaExpressionParseException if {@code expression} cannot be parsed
 */
static JavaExpression atMethodDecl(String expression, ExecutableElement method, SourceChecker checker) throws JavaExpressionParseException {
    TypeMirror enclosingType = ElementUtils.enclosingTypeElement(method).asType();
    ThisReference thisReference;
    if (ElementUtils.isStatic(method)) {
        // Can't use "this" on a static method
        thisReference = null;
    } else {
        thisReference = new ThisReference(enclosingType);
    }
    List<FormalParameter> parameters = JavaExpression.getFormalParameters(method);
    return JavaExpressionParseUtil.parse(expression, enclosingType, thisReference, parameters, null, checker.getPathToCompilationUnit(), checker.getProcessingEnvironment());
}