lombok.ast.grammar.StructuresActions Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lombok.ast Show documentation
An abstract syntax tree for java source code, including a parser and converters to/from ecj (eclipse) and javac.
The newest version!
/*
 * Copyright (C) 2010 The Project Lombok Authors.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package lombok.ast.grammar;

import java.util.List;

import lombok.ast.Annotation;
import lombok.ast.AnnotationDeclaration;
import lombok.ast.AnnotationElement;
import lombok.ast.AnnotationMethodDeclaration;
import lombok.ast.ArrayInitializer;
import lombok.ast.ClassDeclaration;
import lombok.ast.CompilationUnit;
import lombok.ast.ConstructorDeclaration;
import lombok.ast.DanglingNodes;
import lombok.ast.EmptyDeclaration;
import lombok.ast.EnumConstant;
import lombok.ast.EnumDeclaration;
import lombok.ast.EnumTypeBody;
import lombok.ast.ImportDeclaration;
import lombok.ast.InstanceInitializer;
import lombok.ast.InterfaceDeclaration;
import lombok.ast.KeywordModifier;
import lombok.ast.MethodDeclaration;
import lombok.ast.Modifiers;
import lombok.ast.Node;
import lombok.ast.NormalTypeBody;
import lombok.ast.PackageDeclaration;
import lombok.ast.Position;
import lombok.ast.StaticInitializer;
import lombok.ast.TypeBody;
import lombok.ast.TypeReference;
import lombok.ast.VariableDeclaration;
import lombok.ast.VariableDefinition;
import lombok.ast.VariableDefinitionEntry;
import lombok.ast.grammar.TemporaryNode.MethodArguments;

public class StructuresActions extends SourceActions {
	public StructuresActions(Source source) {
		super(source);
	}
	
	public Node createMethodArguments(Node head, List tail) {
		MethodArguments ma = new MethodArguments();
		if (head != null) ma.arguments.add(head);
		if (tail != null) for (Node n : tail) ma.arguments.add(n);
		return posify(ma);
	}
	
	public Node createKeywordModifier(String text) {
		return posify(new KeywordModifier().astName(text));
	}
	
	public Node createMethodDeclaration(Node modifiers, Node typeParameters, Node resultType, Node name,
			Node params, List> dims, Node throwsHead, List throwsTail, Node body) {
		
		MethodDeclaration decl = new MethodDeclaration();
		
		if (params instanceof TemporaryNode.MethodParameters) {
			for (Node param : ((TemporaryNode.MethodParameters)params).parameters) {
				decl.rawParameters().addToEnd(param);
			}
		} else DanglingNodes.addDanglingNode(decl, params);
		
		decl.astMethodName(createIdentifierIfNeeded(name, currentPos())).rawBody(body);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		int extraDims = dims == null ? 0 : dims.size();
		Node returnType = resultType;
		if (extraDims > 0 && returnType instanceof TypeReference) {
			((TypeReference)returnType).astArrayDimensions(((TypeReference)returnType).astArrayDimensions() + extraDims);
		}
		decl.rawReturnTypeReference(returnType);
		if (typeParameters instanceof TemporaryNode.OrphanedTypeVariables) {
			TemporaryNode.OrphanedTypeVariables otv = (TemporaryNode.OrphanedTypeVariables)typeParameters;
			if (otv.variables != null) for (Node typeParameter : otv.variables) {
				if (typeParameter != null) decl.rawTypeVariables().addToEnd(typeParameter);
			}
		}
		
		for (org.parboiled.Node dim : dims) {
			for (org.parboiled.Node dimSub : dim.getChildren()) {
				source.registerStructure(decl, dimSub);
			}
		}
		
		if (throwsHead != null) decl.rawThrownTypeReferences().addToEnd(throwsHead);
		if (throwsTail != null) for (Node n : throwsTail) if (n != null) decl.rawThrownTypeReferences().addToEnd(n);
		return posify(decl);
	}
	
	public Node createConstructorDeclaration(Node modifiers, Node typeParameters, Node name,
			Node params, Node throwsHead, List throwsTail, Node body) {
		
		ConstructorDeclaration decl = new ConstructorDeclaration().astTypeName(
				createIdentifierIfNeeded(name, currentPos())).rawBody(body);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		if (typeParameters instanceof TemporaryNode.OrphanedTypeVariables) {
			for (Node typeParameter : ((TemporaryNode.OrphanedTypeVariables)typeParameters).variables) {
				decl.rawTypeVariables().addToEnd(typeParameter);
			}
		}
		
		if (params instanceof TemporaryNode.MethodParameters) {
			for (Node param : ((TemporaryNode.MethodParameters)params).parameters) {
				decl.rawParameters().addToEnd(param);
			}
		} else DanglingNodes.addDanglingNode(decl, params);
		
		if (throwsHead != null) decl.rawThrownTypeReferences().addToEnd(throwsHead);
		if (throwsTail != null) for (Node n : throwsTail) if (n != null) decl.rawThrownTypeReferences().addToEnd(n);
		return posify(decl);
	}
	
	public Node createModifiers(List values) {
		Modifiers result = new Modifiers();
		if (values != null) for (Node n : values) {
			if (n instanceof Annotation) result.rawAnnotations().addToEnd(n);
			if (n instanceof KeywordModifier) result.rawKeywords().addToEnd(n);
		}
		return posify(result);
	}
	
	public Node createMethodParameter(
			Node modifiers, Node type, String varargs, Node name,
			List> dimOpen, List> dimClosed) {
		
		VariableDefinitionEntry e = new VariableDefinitionEntry().astName(createIdentifierIfNeeded(name, currentPos()))
				.astArrayDimensions(dimOpen == null ? 0 : dimOpen.size());
		if (dimOpen != null) for (org.parboiled.Node pNode : dimOpen) {
			source.registerStructure(e, pNode);
		}
		if (dimClosed != null) for (org.parboiled.Node pNode : dimClosed) {
			source.registerStructure(e, pNode);
		}
		if (name != null) e.setPosition(new Position(name.getPosition().getStart(), currentPos()));
		VariableDefinition decl = new VariableDefinition().rawTypeReference(type);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		if (varargs != null && !varargs.trim().isEmpty()) decl.astVarargs(true);
		decl.rawVariables().addToEnd(e);
		return posify(decl);
	}
	
	public Node createInstanceInitializer(Node body) {
		return posify(new InstanceInitializer().rawBody(body));
	}
	
	public Node createStaticInitializer(Node body) {
		return posify(new StaticInitializer().rawBody(body));
	}
	
	public Node createFieldDeclaration(Node variableDefinition, Node modifiers) {
		if (modifiers != null && variableDefinition instanceof VariableDefinition) {
			((VariableDefinition)variableDefinition).astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		}
		
		return posify(new VariableDeclaration().rawDefinition(variableDefinition));
	}
	
	public Node createVariableDefinitionPart(Node varName, List dims, Node initializer) {
		return posify(new VariableDefinitionEntry().astName(createIdentifierIfNeeded(varName, currentPos()))
				.rawInitializer(initializer).astArrayDimensions(dims == null ? 0 : dims.size()));
	}
	
	public Node createVariableDefinition(Node type, Node head, List tail) {
		VariableDefinition result = new VariableDefinition().rawTypeReference(type);
		if (head != null) result.rawVariables().addToEnd(head);
		if (tail != null) for (Node n : tail) if (n != null) result.rawVariables().addToEnd(n);
		return posify(result);
	}
	
	public Node createAnnotationElementValueArrayInitializer(Node head, List tail) {
		ArrayInitializer result = new ArrayInitializer();
		if (head != null) result.rawExpressions().addToEnd(head);
		if (tail != null) for (Node n : tail) if (n != null) result.rawExpressions().addToEnd(n);
		return posify(result);
	}
	
	public Node createAnnotationElement(Node name, Node value) {
		return posify(new AnnotationElement().astName(createIdentifierIfNeeded(name, currentPos())).rawValue(value));
	}
	
	public Node createAnnotationFromElements(Node head, List tail) {
		Annotation result = new Annotation();
		if (head != null) result.rawElements().addToEnd(head);
		if (tail != null) for (Node n : tail) if (n != null) result.rawElements().addToEnd(n);
		return posify(result);
	}
	
	public Node createAnnotationFromElement(Node value) {
		Annotation result = new Annotation();
		if (value != null) {
			result.rawElements().addToEnd(posify(new AnnotationElement().rawValue(value)));
		}
		return posify(result);
	}
	
	public Node createAnnotation(Node type, Node annotation) {
		if (annotation instanceof Annotation) {
			return posify(((Annotation)annotation).rawAnnotationTypeReference(type));
		}
		return posify(new Annotation().rawAnnotationTypeReference(type));
	}
	
	public Node createExtendsClause(Node head, List tail) {
		TemporaryNode.ExtendsClause result = new TemporaryNode.ExtendsClause();
		if (head != null) result.superTypes.add(head);
		if (tail != null) for (Node n : tail) if (n != null) result.superTypes.add(n);
		return posify(result);
	}
	
	public Node createImplementsClause(Node head, List tail) {
		TemporaryNode.ImplementsClause result = new TemporaryNode.ImplementsClause();
		if (head != null) result.superInterfaces.add(head);
		if (tail != null) for (Node n : tail) if (n != null) result.superInterfaces.add(n);
		return posify(result);
	}
	
	public Node createInterfaceDeclaration(Node modifiers, Node name, Node params, Node body, List addons) {
		InterfaceDeclaration decl = new InterfaceDeclaration().astName(createIdentifierIfNeeded(name, currentPos())).rawBody(body);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		if (params instanceof TemporaryNode.OrphanedTypeVariables) {
			TemporaryNode.OrphanedTypeVariables otv = (TemporaryNode.OrphanedTypeVariables)params;
			if (otv.variables != null) for (Node typeParameter : otv.variables) {
				if (typeParameter != null) decl.rawTypeVariables().addToEnd(typeParameter);
			}
		}
		
		if (addons != null) for (Node n : addons) {
			if (n instanceof TemporaryNode.ExtendsClause) {
				//if (!decl.extending().isEmpty()) //TODO add error node: multiple extends clauses.
				List superClasses = ((TemporaryNode.ExtendsClause)n).superTypes;
				if (superClasses != null) for (Node superClass : superClasses) if (superClass != null) decl.rawExtending().addToEnd(superClass);
			}
			
			//if (n instanceof TemporaryNode.ImplementsClause) //TODO add error node: implements not allowed here.
		}
		
		return posify(decl);
	}
	
	public Node createTypeDeclaration(String kind, Node modifiers, Node name, Node params, Node body, List addons) {
		if (kind.equals("interface")) return createInterfaceDeclaration(modifiers, name, params, body, addons);
		
		ClassDeclaration decl = new ClassDeclaration().astName(createIdentifierIfNeeded(name, currentPos())).rawBody(body);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		if (params instanceof TemporaryNode.OrphanedTypeVariables) {
			TemporaryNode.OrphanedTypeVariables otv = (TemporaryNode.OrphanedTypeVariables)params;
			if (otv.variables != null) for (Node typeParameter : otv.variables) {
				if (typeParameter != null) decl.rawTypeVariables().addToEnd(typeParameter);
			}
		}
		
		if (addons != null) for (Node n : addons) {
			if (n instanceof TemporaryNode.ExtendsClause) {
				//if (!decl.implementing().isEmpty()) //TODO add error node: implements must come after extends
				//if (!decl.extending().isEmpty()) //TODO add error node: multiple extends clauses.
				List superClasses = ((TemporaryNode.ExtendsClause)n).superTypes;
				if (superClasses != null && superClasses.size() > 0) {
					//if (superClasses.size() > 1) //TODO add error node: 'extends' on class can only accept 1 type.
					decl.rawExtending(superClasses.get(0));
				}
			}
			
			if (n instanceof TemporaryNode.ImplementsClause) {
				//if (!decl.implementing().isEmpty()) //TODO add error node: multiple implements clauses.
				List interfaces = ((TemporaryNode.ImplementsClause)n).superInterfaces;
				if (interfaces != null) for (Node i : interfaces) decl.rawImplementing().addToEnd(i);
			}
		}
		return posify(decl);
	}
	
	public Node createNormalTypeBody(List values) {
		NormalTypeBody body = new NormalTypeBody();
		if (values != null) for (Node n : values) body.rawMembers().addToEnd(n);
		return posify(body);
	}
	
	public Node createEnumConstant(List annotations, Node name, Node arguments, Node body) {
		EnumConstant result = new EnumConstant().astName(createIdentifierIfNeeded(name, currentPos())).rawBody(body);
		if (annotations != null) for (Node n : annotations) if (n != null) result.rawAnnotations().addToEnd(n);
		if (arguments instanceof TemporaryNode.MethodArguments) {
			for (Node arg : ((TemporaryNode.MethodArguments)arguments).arguments) {
				result.rawArguments().addToEnd(arg);
			}
		}
		return posify(result);
	}
	
	public Node createEnumBody(Node head, List tail, Node typeBody) {
		EnumTypeBody body = new EnumTypeBody();
		if (head != null) body.rawConstants().addToEnd(head);
		if (tail != null) for (Node n : tail) body.rawConstants().addToEnd(n);
		if (typeBody instanceof TypeBody) {
			body.rawMembers().migrateAllFrom(((TypeBody)typeBody).rawMembers());
		}
		return posify(body);
	}
	
	public Node createEnumDeclaration(Node modifiers, Node name, Node body, List addons) {
		EnumDeclaration decl = new EnumDeclaration();
		decl.astName(createIdentifierIfNeeded(name, currentPos())).rawBody(body);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		if (addons != null) for (Node n : addons) {
			//if (n instanceof ExtendsClause) //TODO add error node: implements not allowed here.
			if (n instanceof TemporaryNode.ImplementsClause) {
				//if (!decl.implementing().isEmpty()) //TODO add error node: multiple implements clauses.
				List interfaces = ((TemporaryNode.ImplementsClause)n).superInterfaces;
				if (interfaces != null) for (Node i : interfaces) decl.rawImplementing().addToEnd(i);
			}
		}
		return posify(decl);
	}
	
	public Node createAnnotationDeclaration(Node modifiers, Node name, List members, org.parboiled.Node typeOpen, org.parboiled.Node typeClose) {
		Node typeBody = createNormalTypeBody(members);
		if (typeOpen != null && typeClose != null) {
			typeBody.setPosition(new Position(typeOpen.getStartIndex(), typeClose.getEndIndex()));
		}
		AnnotationDeclaration decl = new AnnotationDeclaration().astName(createIdentifierIfNeeded(name, currentPos())).rawBody(typeBody);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		return posify(decl);
	}
	
	public Node createAnnotationMethodDeclaration(Node modifiers, Node typeReference, Node name, List> dims, Node defaultValue) {
		AnnotationMethodDeclaration decl = new AnnotationMethodDeclaration()
				.astMethodName(createIdentifierIfNeeded(name, currentPos())).rawDefaultValue(defaultValue);
		if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos()));
		int extraDims = dims == null ? 0 : dims.size();
		Node returnType = typeReference;
		if (extraDims > 0 && returnType instanceof TypeReference) {
			((TypeReference)returnType).astArrayDimensions(((TypeReference)returnType).astArrayDimensions() + extraDims);
		}
		decl.rawReturnTypeReference(returnType);
		return posify(decl);
	}
	
	public Node createPackageDeclaration(List annotations, Node head, List tail) {
		PackageDeclaration decl = new PackageDeclaration();
		if (annotations != null) for (Node n : annotations) if (n != null) decl.rawAnnotations().addToEnd(n);
		if (head != null) decl.rawParts().addToEnd(head);
		if (tail != null) for (Node n : tail) if (n != null) decl.rawParts().addToEnd(n);
		return posify(decl);
	}
	
	public Node createImportDeclaration(String staticKeyword, Node head, List tail, String dotStar) {
		ImportDeclaration decl = new ImportDeclaration();
		if (head != null) decl.rawParts().addToEnd(head);
		if (tail != null) for (Node n : tail) decl.rawParts().addToEnd(n);
		if (staticKeyword != null && staticKeyword.length() > 0) decl.astStaticImport(true);
		if (dotStar != null && dotStar.length() > 0) decl.astStarImport(true);
		return posify(decl);
	}
	
	public Node createCompilationUnit(Node packageDeclaration, List importDeclarations, List typeDeclarations) {
		CompilationUnit unit = new CompilationUnit().rawPackageDeclaration(packageDeclaration);
		if (importDeclarations != null) for (Node n : importDeclarations) if (n != null) unit.rawImportDeclarations().addToEnd(n);
		if (typeDeclarations != null) for (Node n : typeDeclarations) if (n != null) unit.rawTypeDeclarations().addToEnd(n);
		return posify(unit);
	}
	
	public Node createMethodParameters(Node head, List tail) {
		TemporaryNode.MethodParameters params = new TemporaryNode.MethodParameters();
		if (head != null) params.parameters.add(head);
		if (tail != null) for (Node n : tail) if (n != null) params.parameters.add(n);
		
		return params;
	}
	
	public Node createEmptyDeclaration() {
		return posify(new EmptyDeclaration());
	}
}