Skip to main content

module AST

rascal-0.28.2

Usage

import lang::java::m3::AST;

Dependencies

extend analysis::m3::AST;
extend analysis::m3::Core;
extend lang::java::m3::TypeSymbol;
import util::FileSystem;
import util::Reflective;
import IO;
import String;
import List;

Synopsis

AST node declarations for Java

data Declaration

data Declaration  
= \compilationUnit(list[Declaration] imports, list[Declaration] types)
| \compilationUnit(Declaration package, list[Declaration] imports, list[Declaration] types)
| \enum(str name, list[Type] implements, list[Declaration] constants, list[Declaration] body)
| \enumConstant(str name, list[Expression] arguments, Declaration class)
| \enumConstant(str name, list[Expression] arguments)
| \class(str name, list[Type] extends, list[Type] implements, list[Declaration] body)
| \class(list[Declaration] body)
| \interface(str name, list[Type] extends, list[Type] implements, list[Declaration] body)
| \field(Type \type, list[Expression] fragments)
| \initializer(Statement initializerBody)
| \method(Type \return, str name, list[Declaration] parameters, list[Expression] exceptions, Statement impl)
| \method(Type \return, str name, list[Declaration] parameters, list[Expression] exceptions)
| \constructor(str name, list[Declaration] parameters, list[Expression] exceptions, Statement impl)
| \import(str name)
| \package(str name)
| \package(Declaration parentPackage, str name)
| \variables(Type \type, list[Expression] \fragments)
| \typeParameter(str name, list[Type] extendsList)
| \annotationType(str name, list[Declaration] body)
| \annotationTypeMember(Type \type, str name)
| \annotationTypeMember(Type \type, str name, Expression defaultBlock)
| \parameter(Type \type, str name, int extraDimensions)
| \vararg(Type \type, str name)
;

data Expression

data Expression  
= \arrayAccess(Expression array, Expression index)
| \newArray(Type \type, list[Expression] dimensions, Expression init)
| \newArray(Type \type, list[Expression] dimensions)
| \arrayInitializer(list[Expression] elements)
| \assignment(Expression lhs, str operator, Expression rhs)
| \cast(Type \type, Expression expression)
| \characterLiteral(str charValue)
| \newObject(Expression expr, Type \type, list[Expression] args, Declaration class)
| \newObject(Expression expr, Type \type, list[Expression] args)
| \newObject(Type \type, list[Expression] args, Declaration class)
| \newObject(Type \type, list[Expression] args)
| \qualifiedName(Expression qualifier, Expression expression)
| \conditional(Expression expression, Expression thenBranch, Expression elseBranch)
| \fieldAccess(bool isSuper, Expression expression, str name)
| \fieldAccess(bool isSuper, str name)
| \instanceof(Expression leftSide, Type rightSide)
| \methodCall(bool isSuper, str name, list[Expression] arguments)
| \methodCall(bool isSuper, Expression receiver, str name, list[Expression] arguments)
| \null()
| \number(str numberValue)
| \booleanLiteral(bool boolValue)
| \stringLiteral(str stringValue)
| \type(Type \type)
| \variable(str name, int extraDimensions)
| \variable(str name, int extraDimensions, Expression \initializer)
| \bracket(Expression expression)
| \this()
| \this(Expression thisExpression)
| \super()
| \declarationExpression(Declaration declaration)
| \infix(Expression lhs, str operator, Expression rhs)
| \postfix(Expression operand, str operator)
| \prefix(str operator, Expression operand)
| \simpleName(str name)
| \markerAnnotation(str typeName)
| \normalAnnotation(str typeName, list[Expression] memberValuePairs)
| \memberValuePair(str name, Expression \value)
| \singleMemberAnnotation(str typeName, Expression \value)
;

data Statement

data Statement  
= \assert(Expression expression)
| \assert(Expression expression, Expression message)
| \block(list[Statement] statements)
| \break()
| \break(str label)
| \continue()
| \continue(str label)
| \do(Statement body, Expression condition)
| \empty()
| \foreach(Declaration parameter, Expression collection, Statement body)
| \for(list[Expression] initializers, Expression condition, list[Expression] updaters, Statement body)
| \for(list[Expression] initializers, list[Expression] updaters, Statement body)
| \if(Expression condition, Statement thenBranch)
| \if(Expression condition, Statement thenBranch, Statement elseBranch)
| \label(str name, Statement body)
| \return(Expression expression)
| \return()
| \switch(Expression expression, list[Statement] statements)
| \case(Expression expression)
| \defaultCase()
| \synchronizedStatement(Expression lock, Statement body)
| \throw(Expression expression)
| \try(Statement body, list[Statement] catchClauses)
| \try(Statement body, list[Statement] catchClauses, Statement \finally)
| \catch(Declaration exception, Statement body)
| \declarationStatement(Declaration declaration)
| \while(Expression condition, Statement body)
| \expressionStatement(Expression stmt)
| \constructorCall(bool isSuper, Expression expr, list[Expression] arguments)
| \constructorCall(bool isSuper, list[Expression] arguments)
;

data Type

data Type  
= arrayType(Type \type)
| parameterizedType(Type \type)
| qualifiedType(Type qualifier, Expression simpleName)
| simpleType(Expression typeName)
| unionType(list[Type] types)
| wildcard()
| upperbound(Type \type)
| lowerbound(Type \type)
| \int()
| short()
| long()
| float()
| double()
| char()
| string()
| byte()
| \void()
| \boolean()
;

data Modifier

data Modifier  
= \private()
| \public()
| \protected()
| \friendly()
| \static()
| \final()
| \synchronized()
| \transient()
| \abstract()
| \native()
| \volatile()
| \strictfp()
| \annotation(Expression \anno)
| \onDemand()
| \default()
;

function getPaths

set[loc] getPaths(loc dir, str suffix)

function findRoots

set[loc] findRoots(set[loc] folders)

function createAstFromFile

Synopsis

Creates AST from a file

Description

Declaration createAstFromFile(loc file, bool collectBindings, bool errorRecovery = false, list[loc] sourcePath = [], list[loc] classPath = [], str javaVersion = "1.7")

function createAstsFromFiles

Synopsis

Creates AST from a file using Eclipse JDT compiler

set[Declaration] createAstsFromFiles(set[loc] file, bool collectBindings, bool errorRecovery = false, list[loc] sourcePath = [], list[loc] classPath = [], str javaVersion = "1.7")

function createAstFromString

Synopsis

Creates AST from a string using Eclipse JDT compiler

Declaration createAstFromString(loc fileName, str source, bool collectBinding, bool errorRecovery = false, list[loc] sourcePath = [], list[loc] classPath = [], str javaVersion = "1.7")

function createAstsFromDirectory

Creates a set ASTs for all Java source files in a project using Eclipse's JDT compiler

set[Declaration] createAstsFromDirectory(loc project, bool collectBindings, bool errorRecovery = false, str javaVersion = "1.7" )

function createAstsFromMavenProject

Creates a set ASTs for all Java source files in a Maven project using Eclipse's JDT compiler

Description

This function uses Reflective-getProjectPathConfig, which inspects a pom.xml to compute the dependencies and concrete locations of jar files that a Maven project depends on.

set[Declaration] createAstsFromMavenProject(loc project, bool collectBindings, bool errorRecovery = false, str javaVersion = "1.7" )