/**
* Constructor.
*
* @param pTree The tree node representing a <code>switch</code> statement.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2TryStatement(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ElementType.TRY_STATEMENT,pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.TRY)
{
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if (pTree.ChildCount > 1)
{
// The next child may be an 'catch' clause list or a 'finally'
// clause.
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(1);
if (child.Type == JavaTreeParser.CATCH_CLAUSE_LIST)
{
if (child.ChildCount > 0)
{
mCatchClauseListTree = child;
}
if (pTree.ChildCount == 3)
{
// Switch forward to the 'finally' clause.
child = (AST2JSOMTree)pTree.GetChild(2);
}
else
{
child = null;
}
}
if (child != null)
{
mFinallyBlockScopeTree = child;
}
}
}
/**
* Constructor.
*
* @param pTree The root tree representing a class constructor call.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2ClassConstructorCall(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ExpressionType.CLASS_CONSTRUCTOR_CALL,pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.CLASS_CONSTRUCTOR_CALL) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
// Get the optional generic type argument list. If there is no such list
// it's the identifier.
int offset = 0;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(offset);
if (child.Type == JavaTreeParser.GENERIC_TYPE_ARG_LIST) {
// Remember the generic type argument list.
mGenericTypeArgumentListTree = child;
// Switch forward to the identifier.
offset++;
child = (AST2JSOMTree)pTree.GetChild(offset);
}
if (child.Type != JavaTreeParser.IDENT) {
// 'mIdentifierTree' must get resolved just in time.
mQualifiedTypeIdentTree = child;
} else {
// 'mQualifiedTypeIdentTree' remains 'null' for inner new
// expressions.
mIdentifierTree = child;
}
// If there are arguments get and remember them.
offset++;
mArgumentListTree = (AST2JSOMTree)pTree.GetChild(offset);
if (mArgumentListTree.ChildCount == 0) {
mArgumentListTree = null;
}
// Get and remember optional class scope declarations.
offset++;
if (offset == pTree.ChildCount - 1) {
mClassScopeDeclTree = (AST2JSOMTree)pTree.GetChild(offset);
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a <code>forEach</code>
* statement.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2ForEachStatement(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ElementType.FOR_EACH_STATEMENT,pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.FOR_EACH) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if (pTree.GetChild(0).ChildCount > 0) {
mHasModifier = true;
}
mIdentifierTree = (AST2JSOMTree)pTree.GetChild(2);
}
/**
* Constructor.
* <p>
* If classes derived from this class should be recognized by another JSOM
* type than <code>JSOMType.VARIABLE_DECLARATION</code> they must call
* this constructor via the explicit super constructor call.
*
* @param pTree The tree node representing a variable declaration.
* @param pJSOMType The JSOM type of the new instance.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
protected AST2CommonVariableDeclaration(
AST2JSOMTree pTree, JSOMType pJSOMType,
TokenRewriteStream pTokenRewriteStream)
: base(pTree, pJSOMType, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.VAR_DECLARATION) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if (pTree.GetChild(0).ChildCount == 0) {
mHasModifier = false;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a method declaration.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2AnnotationMethodDeclaration(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.ANNOTATION_METHOD_DECLARATION, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.ANNOTATION_METHOD_DECL) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
mModifierListTree = (AST2JSOMTree)pTree.GetChild(0);
mIdentifierTree = (AST2JSOMTree)pTree.GetChild(2);
if (pTree.ChildCount == 4) {
mHasDefaultValue = true;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing an interface declaration.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2InterfaceDeclaration(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.INTERFACE_DECLARATION, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.INTERFACE) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int childOffset = 2;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(childOffset);
if (child.Type == JavaTreeParser.GENERIC_TYPE_PARAM_LIST) {
mGenericTypeParamTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
if (child.Type == JavaTreeParser.EXTENDS_CLAUSE) {
mExtendsClauseTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
mScopeTree = child;
}
/**
* Constructor.
*
* @param pTree The tree node representing a <code>break</code> statement.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2BreakStatement(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ElementType.BREAK_STATEMENT, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.BREAK)
{
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if (pTree.ChildCount == 1)
{
mLabelNode = (AST2JSOMTree)pTree.GetChild(0);
}
}
/**
* Constructor.
*
* @param pTree The tree node representing an annotation.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2Annotation(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.ANNOTATION, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.AT) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if ( pTree.ChildCount == 2
&& pTree.GetChild(1).ChildCount == 1) {
mHasInitializers = true;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing an enumeration declaration.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2EnumDeclaration(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.ENUM_DECLARATION, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.ENUM) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(2);
if (child.Type == JavaTreeParser.IMPLEMENTS_CLAUSE) {
mImplementsClauseTree = child;
child = (AST2JSOMTree)pTree.GetChild(3);
}
mScopeTree = child;
}
/**
* Constructor.
*
* @param pTree The tree node representing a type.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2MethodCall(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ExpressionType.METHOD_CALL, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.METHOD_CALL) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
// Check if there is a generic type argument list.
ITree child = pTree.GetChild(1);
if (child.Type == JavaTreeParser.GENERIC_TYPE_ARG_LIST) {
if (child.ChildCount > 0) {
mHasGenericTypeArgumentList = true;
}
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a variable initializer, i.e.
* an expression or an array initializer.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2StaticArrayCreator(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ExpressionType.STATIC_ARRAY_CREATOR,pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.STATIC_ARRAY_CREATOR) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int childOffset = 0;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(childOffset);
if (AST2PrimitiveType.isPrimitiveType(child)) {
mIsArrayOfPrimitiveType = true;
mPrimitiveTypeTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
} else {
if (child.Type == JavaTreeParser.GENERIC_TYPE_ARG_LIST) {
mGenericTypeArgsTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
mQualifiedTypeIdentTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
if (child.Type == JavaTreeParser.EXPR) {
int numberOfExpressions = 1;
int childOffsetBuffer = childOffset + 1;
while ( childOffsetBuffer < pTree.ChildCount
&& pTree.GetChild(childOffsetBuffer).Type
== JavaTreeParser.EXPR) {
numberOfExpressions++;
childOffsetBuffer++;
}
mArrayDimTrees = new List<AST2JSOMTree>(numberOfExpressions);
mArrayDimTrees.Add(child); // Add the first expressions.
for (int offset = 1; offset < numberOfExpressions; offset++) {
// Add rest of expressions.
childOffset++;
mArrayDimTrees.Add((AST2JSOMTree)pTree.GetChild(childOffset));
}
// Check if there is still an array declarator list.
childOffset++;
if (childOffset == pTree.ChildCount - 1) {
mNumberOfArrayDeclarators =
pTree.GetChild(childOffset).ChildCount;
}
} else {
mHasExplicitInitializer = true;
// The array creator has an explicit initializer.
mNumberOfArrayDeclarators =
pTree.GetChild(childOffset).ChildCount;
// Get the initializers
child = (AST2JSOMTree)pTree.GetChild(childOffset + 1);
int numberOfInitializers = child.ChildCount;
if (numberOfInitializers > 0) {
mArrayInitializersTree = child;
}
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a type.
* @param pJavaSourceIdentifier The identifier of the Java source, for
* example the Java file name (without the
* <i>.java</code> suffix). If the origin of
* the parsed Java source isn't a file then a
* name must be stated if it would be a file.
* That means that the name should match the
* public type declaration within the Java
* source. However, this will not be checked
* by this class and it's up to the caller to
* pass the correct file name or at least to
* interpret what's <i>correct</i>.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2JavaSource(
AST2JSOMTree pTree, String pJavaSourceIdentifier,
TokenRewriteStream pTokenRewriteStream, int pLineCount)
: base(pTree, JSOMType.JAVA_SOURCE, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.JAVA_SOURCE) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
mLineCount = pLineCount;
mJavaSourceIdentifier = pJavaSourceIdentifier;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(0);
if (child.ChildCount > 0) {
mAnnotationsTree = child;
}
int numberOfChildren = pTree.ChildCount;
if (numberOfChildren > 1) {
int childOffset = 1;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
if (child.Type == JavaTreeParser.PACKAGE) {
mPackageDeclTree = child;
childOffset++;
}
int importDeclCtr = 0;
int typeDeclCtr = 0;
int childOffsetBuffer = childOffset;
while ( childOffset < numberOfChildren
&& pTree.GetChild(childOffset).Type
== JavaTreeParser.IMPORT) {
importDeclCtr++;
childOffset++;
}
typeDeclCtr = numberOfChildren - childOffset;
if (importDeclCtr > 0) {
mImportDeclTrees = new List<AST2JSOMTree>(importDeclCtr);
while (importDeclCtr > 0) {
mImportDeclTrees.Add((AST2JSOMTree)pTree.GetChild(childOffsetBuffer));
childOffsetBuffer++;
importDeclCtr--;
}
}
if (typeDeclCtr > 0) {
mTypeDeclTrees = new List<AST2JSOMTree>(typeDeclCtr);
while (typeDeclCtr > 0) {
mTypeDeclTrees.Add((AST2JSOMTree)pTree.GetChild(childOffsetBuffer));
childOffsetBuffer++;
typeDeclCtr--;
}
}
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a type.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2Type(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.TYPE, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.TYPE) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if ( pTree.GetChild(0).Type
== JavaTreeParser.QUALIFIED_TYPE_IDENT) {
mIsComplexType = true;
}
}
/**
* Constructor.
* <p>
* This constructor is used to create a <code>JSOM</code> object
* representing a more or less detailed method declaration. An example would
* be a method definition, i.e. a method signature followed by a statement
* block scope.
*
* @param pTree The tree node representing a method declaration.
* @param pJSOMType One of the <code>JSOMType.???</code> constants defined
* by the interface <code>JSOM</code>.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
protected AST2MethodDeclaration(
AST2JSOMTree pTree, JSOMType pJSOMType,
TokenRewriteStream pTokenRewriteStream)
: base(pTree, pJSOMType, pTokenRewriteStream)
{
if (pTree.Type == JavaTreeParser.FUNCTION_METHOD_DECL) {
// Get the type child.
int offset = 1;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(offset);
if (child.Type == JavaTreeParser.GENERIC_TYPE_PARAM_LIST) {
offset++;
child = (AST2JSOMTree)pTree.GetChild(offset);
}
mReturnTypeTree = child;
// Get the identifier.
offset++;
mIdentifierTree = (AST2JSOMTree)pTree.GetChild(offset);
// Is there an array declarator list behind the formal parameter
// list?
offset += 2;
if (offset < pTree.ChildCount) {
child = (AST2JSOMTree)pTree.GetChild(offset);
if (child.Type == JavaTreeParser.ARRAY_DECLARATOR_LIST) {
mNumberOfArrayDeclarators = child.ChildCount;
}
}
} else if (pTree.Type == JavaTreeParser.VOID_METHOD_DECL) {
// For void method only the identifier must be fetched.
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(1);
if (child.Type == JavaTreeParser.GENERIC_TYPE_PARAM_LIST) {
child = (AST2JSOMTree)pTree.GetChild(2);
}
mIdentifierTree = child;
} else {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
}
/**
* Resolves a generic type parameter list.
*
* @param pTree The generic type parameter list's root node.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*
* @return A list containing the generic type parameters.
*/
public static List<AST2GenericTypeParameter> resolveGenericTypeParameterList(
AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.GENERIC_TYPE_PARAM_LIST) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int size = pTree.ChildCount;
List<AST2GenericTypeParameter> result =
new List<AST2GenericTypeParameter>(size);
for (int offset = 0; offset < size; offset++) {
result.Add(new AST2GenericTypeParameter((AST2JSOMTree)
pTree.GetChild(offset), pTokenRewriteStream));
}
return result;
}
/**
* Constructor.
*
* @param pTree The tree node representing an array type declarator.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2ArrayTypeDeclarator(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ExpressionType.ARRAY_TYPE_DECLARATOR, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.ARRAY_DECLARATOR) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
mTypeTree = (AST2JSOMTree)pTree.GetChild(0);
// Count all 1+ array declarators (the first array declarator is
// represented by the root and mustn't counted).
while (mTypeTree.Type == JavaTreeParser.ARRAY_DECLARATOR) {
// Walk down the sub-trees until the type has been found, i.e. the
// current child doesn't represent an array declarator.
mNumberOfArrayDeclarators++;
mTypeTree = (AST2JSOMTree)mTypeTree.GetChild(0);
}
if (!AST2PrimitiveType.isPrimitiveType(mTypeTree)) {
mIsArrayOfPrimitiveType = false;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a labeled statement.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2LabeledStatement(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ElementType.LABELED_STATEMENT, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.LABELED_STATEMENT)
{
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
mIdentifierTree = (AST2JSOMTree)pTree.GetChild(0);
}
/**
* Resolves a qualified type identifier.
*
* @param pTree The qualified type identifier's root node.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*
* @return A list containing the identifiers from the qualified type
* identifier.
*/
public static List<AST2ComplexTypeIdentifier> resolveQualifiedTypeIdentifier(
AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.QUALIFIED_TYPE_IDENT) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int size = pTree.ChildCount;
List<AST2ComplexTypeIdentifier> result =
new List<AST2ComplexTypeIdentifier>(size);
for (int offset = 0; offset < size; offset++) {
result.Add(new AST2ComplexTypeIdentifier((AST2JSOMTree)
pTree.GetChild(offset), pTokenRewriteStream));
}
return result;
}
/**
* Constructor.
*
* @param pTree The tree node representing a <code>for</code> statement.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2ForStatement(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ElementType.FOR_STATEMENT,pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.FOR) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
ITree child = pTree.GetChild(0);
if (child.ChildCount == 0) {
mForInitType = ForInitType.NONE;
} else if ( child.GetChild(0).Type
== JavaTreeParser.VAR_DECLARATION) {
mForInitType = ForInitType.VAR_DECL;
} else {
mForInitType = ForInitType.EXPRESSION;
}
if (pTree.GetChild(1).ChildCount == 0) {
mHasForCondition = false;
}
child = pTree.GetChild(2);
if (pTree.GetChild(2).ChildCount == 0) {
mHasForUpdater = false;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a type.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2EnumConstant(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.ENUM_CONSTANT, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.IDENT) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(0);
if (child.ChildCount > 0) {
mHasAnnotations = true;
}
if (pTree.ChildCount > 1) {
// The next child may be an argument list or a class scope.
child = (AST2JSOMTree)pTree.GetChild(1);
if (child.Type == JavaTreeParser.ARGUMENT_LIST) {
if (child.ChildCount > 0) {
mArgumentsTree = child;
}
if (pTree.ChildCount == 3) {
// Switch forward to the class scope.
child = (AST2JSOMTree)pTree.GetChild(2);
} else {
child = null;
}
}
if (child != null) {
mClassScopeTree = child;
}
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a <code>switch</code> statement.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2SwitchStatement(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ElementType.SWITCH_STATEMENT, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.SWITCH) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
if (pTree.GetChild(1).ChildCount == 0) {
mHasSwitchLabels = false;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing any type declaration, i.e. a
* a class declaration, for example. Note that it's up to
* derived classes to check that the given tree node is of a
* valid type.
* @param pJSOMType One of the <code>JSOMType.???</code> constants defined
* by the interface <code>JSOM</code>.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
protected AST2CommonTypeDeclaration(
AST2JSOMTree pTree, JSOMType pJSOMType,
TokenRewriteStream pTokenRewriteStream)
: base(pTree, pJSOMType, pTokenRewriteStream)
{
if (pTree.GetChild(0).ChildCount == 0) {
mHasModifier = false;
}
mIdentifierTree = (AST2JSOMTree)getTreeNode().GetChild(1);
}
/**
* Constructor.
*
* @param pTree The tree node representing an enumeration top level scope.
* @param pOwner The enumeration declaration the new object belongs to.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2EnumTopLevelScope(
AST2JSOMTree pTree, AST2EnumDeclaration pOwner,
TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.ENUM_TOP_LEVEL_SCOPE, pTokenRewriteStream)
{
mOwner = pOwner;
if (pTree.Type != JavaTreeParser.ENUM_TOP_LEVEL_SCOPE) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int numberOfConsts = pTree.ChildCount;
// Check if the last child is a class top level scope.
if ( numberOfConsts > 0
&& pTree.GetChild(numberOfConsts - 1).Type
== JavaTreeParser.CLASS_TOP_LEVEL_SCOPE) {
mHasClassScope = true;
numberOfConsts--;
}
if (numberOfConsts == 0) {
mHasEnumConstants = false;
}
}
/**
* Resolves the content of the modifier list.
*
* @param pTree The tree node representing a modifier list.
*/
private void resolveModifierList(AST2JSOMTree pTree)
{
int numberOfChildren = pTree.ChildCount;
if (numberOfChildren > 0) {
mModifierTypes = new List<Modifier>(numberOfChildren);
int numberOfAnnotations = 0;
for (int offset = 0; offset < numberOfChildren; offset++) {
if (pTree.GetChild(offset).Type == JavaTreeParser.AT) {
numberOfAnnotations++;
}
}
if (numberOfAnnotations > 0) {
mAnnotationTrees =
new List<AST2JSOMTree>(numberOfAnnotations);
}
if (numberOfChildren > numberOfAnnotations) {
mHasModifiers = true;
}
for (int offset = 0; offset < numberOfChildren; offset++) {
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(offset);
switch (child.Type) {
// Handle annotations and the modifier 'final' at first
// because the rest is irrelevant for local modifiers.
case JavaTreeParser.AT:
mAnnotationTrees.Add(child);
mModifierTypes.Add(Modifier.ANNOTATION);
break;
case JavaTreeParser.FINAL:
mModifierTypes.Add(Modifier.FINAL);
break;
case JavaTreeParser.PUBLIC:
mModifierTypes.Add(Modifier.PUBLIC);
break;
case JavaTreeParser.PROTECTED:
mModifierTypes.Add(Modifier.PROTECTED);
break;
case JavaTreeParser.PRIVATE:
mModifierTypes.Add(Modifier.PRIVATE);
break;
case JavaTreeParser.STATIC:
mModifierTypes.Add(Modifier.STATIC);
break;
case JavaTreeParser.ABSTRACT:
mModifierTypes.Add(Modifier.ABSTRACT);
break;
case JavaTreeParser.NATIVE:
mModifierTypes.Add(Modifier.NATIVE);
break;
case JavaTreeParser.SYNCHRONIZED:
mModifierTypes.Add(Modifier.SYNCHRONIZED);
break;
case JavaTreeParser.TRANSIENT:
mModifierTypes.Add(Modifier.TRANSIENT);
break;
case JavaTreeParser.VOLATILE:
mModifierTypes.Add(Modifier.VOLATILE);
break;
case JavaTreeParser.STRICTFP:
mModifierTypes.Add(Modifier.STRICTFP);
break;
default:
mModifierTypes.Add(Modifier.NOT_SUPPORTED);
break;
}
}
}
}
/**
* Constructor.
*
* @param pTree The root tree of a dot expression.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2DotExpression(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ExpressionType.DOT_EXPRESSION, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.DOT) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
// Resolve the dot expression type.
ITree leftTree = pTree.GetChild(0);
if (AST2PrimitiveType.isPrimitiveType(leftTree)) {
mDotExprType = DotExprType.PRIMITIVE_TYPE_DOT_CLASS;
} else if (leftTree.Type == JavaTreeParser.VOID) {
// The keywords 'void' and 'class' can't get resolved by the
// standard expression resolvers.
mDotExprType = DotExprType.VOID_DOT_CLASS;
} else {
// There's any primary Expression at the left side from the dot.
mDotExprType = DotExprType.DOTEXPR_TYPE_1_VARIANTS;
}
}
/**
* Constructor.
*
* @param pTree The tree node representing a type.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
public AST2ExplicitConstructorCall(
AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, ExpressionType.EXPLICIT_CONSTRUCTOR_CALL,pTokenRewriteStream)
{
if (pTree.Type == JavaTreeParser.SUPER_CONSTRUCTOR_CALL)
{
mIsSuperConstructorCall = true;
}
else if (pTree.Type != JavaTreeParser.THIS_CONSTRUCTOR_CALL)
{
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int offset = 0;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(offset);
// 'super' constructor calls may be preceded by a primary expression
// stating the constructor's owner.
if (mIsSuperConstructorCall
&& child.Type != JavaTreeParser.GENERIC_TYPE_ARG_LIST
&& child.Type != JavaTreeParser.ARGUMENT_LIST)
{
// There must be a primary expression tree.
mPrimaryExprTree = child;
offset++;
child = (AST2JSOMTree)pTree.GetChild(offset);
}
// Check if there is a generic type argument list.
if (child.Type == JavaTreeParser.GENERIC_TYPE_ARG_LIST)
{
mGenericTypeArgumentListTree = child;
offset++;
child = (AST2JSOMTree)pTree.GetChild(offset);
}
// Get the optional arguments.
if (child.ChildCount > 0)
{
mArgumentListTree = child;
}
}
/**
* Constructor.
* <p>
* If classes derived from this class should be recognized by another JSOM
* type than <code>JSOMType.CLASS_DECLARATION</code> they must call this
* constructor via the explicit super constructor call and state the
* appropriate <code>JSOMType</code> explicitly.
*
* @param pTree The tree node representing a class declaration.
* @param pJSOMType The JSOM type of the new instance.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
protected AST2ClassDeclaration(
AST2JSOMTree pTree, JSOMType pJSOMType,
TokenRewriteStream pTokenRewriteStream)
: base(pTree, pJSOMType, pTokenRewriteStream)
{
if (pTree.Type != JavaTreeParser.CLASS) {
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
int childOffset = 2;
AST2JSOMTree child = (AST2JSOMTree)pTree.GetChild(childOffset);
if (child.Type == JavaTreeParser.GENERIC_TYPE_PARAM_LIST) {
mGenericTypeParamTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
if (child.Type == JavaTreeParser.EXTENDS_CLAUSE) {
mExtendsClauseTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
if (child.Type == JavaTreeParser.IMPLEMENTS_CLAUSE) {
mImplementsClauseTree = child;
childOffset++;
child = (AST2JSOMTree)pTree.GetChild(childOffset);
}
mScopeTree = child;
}
/**
* Constructor.
*
* @param pTree The tree node representing a formal parameter declaration.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*
*/
public AST2FormalParameterDeclaration(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.FORMAL_PARAMETER_DECLARATION, pTokenRewriteStream)
{
if (pTree.Type == JavaTreeParser.FORMAL_PARAM_VARARG_DECL)
{
mIsVarArgParam = true;
}
else if (pTree.Type != JavaTreeParser.FORMAL_PARAM_STD_DECL)
{
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
mHasModifier = pTree.GetChild(0).ChildCount > 0;
}
/**
* Constructor.
*
* @param pTree One of the two possible generic type argument root nodes.
* @param pTokenRewriteStream The token stream the token of the stated
* tree node belongs to.
*/
private AST2GenericTypeArgument(AST2JSOMTree pTree, TokenRewriteStream pTokenRewriteStream)
: base(pTree, JSOMType.GENERIC_TYPE_ARGUMENT, pTokenRewriteStream)
{
switch (pTree.Type)
{
case JavaTreeParser.TYPE:
mVariant = Variant.NOT_WILDCARDED;
break;
case JavaTreeParser.QUESTION:
if (pTree.ChildCount == 0)
{
mVariant = Variant.WILDCARDED_NOT_BOUND;
}
else
{
ITree child = pTree.GetChild(0);
if (child.Type == JavaTreeParser.EXTENDS)
{
mVariant = Variant.WILDCARDED_EXTENDS_BOUND;
}
else
{
mVariant = Variant.WILDCARDED_SUPER_BOUND;
}
}
break;
default:
throw new ArgumentException(
CommonErrorMessages.getInvalidArgumentValueMessage(
"pTree.Type == " + pTree.Type, "pTree"));
}
}
