org.eclipse.jdt.internal.compiler.parser.RecoveredAnnotation Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of vaadin-client-compiler-deps Show documentation
Vaadin is a web application framework for Rich Internet Applications (RIA). Vaadin enables easy development and maintenance of fast and secure rich web applications with a stunning look and feel and a wide browser support. It features a server-side architecture with the majority of the logic running on the server. Ajax technology is used at the browser-side to ensure a rich and interactive user experience.
There is a newer version: 1.2.0
Show newest version
/*******************************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.parser;

import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;
import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
import org.eclipse.jdt.internal.compiler.ast.NormalAnnotation;
import org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation;
import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;

public class RecoveredAnnotation extends RecoveredElement {
	public static final int MARKER = 0;
	public static final int NORMAL = 1;
	public static final int SINGLE_MEMBER = 2;
	
	private int kind;
	private int identifierPtr;
	private int identifierLengthPtr;
	private int sourceStart;
	public boolean hasPendingMemberValueName;
	public int memberValuPairEqualEnd = -1;
	public Annotation annotation;

	public RecoveredAnnotation(int identifierPtr, int identifierLengthPtr, int sourceStart, RecoveredElement parent, int bracketBalance) {
		super(parent, bracketBalance);
		this.kind = MARKER;
		this.identifierPtr = identifierPtr;
		this.identifierLengthPtr = identifierLengthPtr;
		this.sourceStart = sourceStart;
	}
	
	public RecoveredElement add(TypeDeclaration typeDeclaration, int bracketBalanceValue) {
		if (annotation == null && (typeDeclaration.bits & ASTNode.IsAnonymousType) != 0){
			// ignore anonymous type in annotations when annotation isn't fully recovered
			return this;
		}
		return super.add(typeDeclaration, bracketBalanceValue);
	}
	
	public RecoveredElement addAnnotationName(int identPtr, int identLengthPtr, int annotationStart, int bracketBalanceValue) {

		RecoveredAnnotation element = new RecoveredAnnotation(identPtr, identLengthPtr, annotationStart, this, bracketBalanceValue);
		
		return element;
	}
	
	public RecoveredElement addAnnotation(Annotation annot, int index) {
		this.annotation = annot;
		
		if (parent != null) return parent;
		return this;
	}
	
	public void updateFromParserState() {
		Parser parser = this.parser();
		
		if (annotation == null && this.identifierPtr <= parser.identifierPtr) {
			Annotation annot = null;
			
			boolean needUpdateRParenPos = false;
			
			MemberValuePair pendingMemberValueName = null;
			if (this.hasPendingMemberValueName && this.identifierPtr < parser.identifierPtr) {
				char[] memberValueName = parser.identifierStack[this.identifierPtr + 1];
				
				long pos = parser.identifierPositionStack[this.identifierPtr + 1];
				int start = (int) (pos >>> 32);
				int end = (int)pos;
				int valueEnd = this.memberValuPairEqualEnd > -1 ? this.memberValuPairEqualEnd : end;
				
				SingleNameReference fakeExpression = new SingleNameReference(RecoveryScanner.FAKE_IDENTIFIER, (((long) valueEnd + 1) << 32) + (valueEnd));
				pendingMemberValueName = new MemberValuePair(memberValueName, start, end, fakeExpression);
			}
			parser.identifierPtr = this.identifierPtr;
			parser.identifierLengthPtr = this.identifierLengthPtr;
			TypeReference typeReference = parser.getAnnotationType();
			
			switch (this.kind) {
				case NORMAL:
					if (parser.astPtr > -1 && parser.astStack[parser.astPtr] instanceof MemberValuePair) {
						MemberValuePair[] memberValuePairs = null;
						
						int argLength = parser.astLengthStack[parser.astLengthPtr];
						int argStart = parser.astPtr - argLength + 1;
						
						if (argLength > 0) {
							int annotationEnd;
							if (pendingMemberValueName != null) {
								memberValuePairs = new MemberValuePair[argLength + 1];
								
								System.arraycopy(parser.astStack, argStart, memberValuePairs, 0, argLength);
								parser.astLengthPtr--;
								parser.astPtr -= argLength;
								
								memberValuePairs[argLength] = pendingMemberValueName;
								
								annotationEnd = pendingMemberValueName.sourceEnd;
							} else {
								memberValuePairs = new MemberValuePair[argLength];
								
								System.arraycopy(parser.astStack, argStart, memberValuePairs, 0, argLength);
								parser.astLengthPtr--;
								parser.astPtr -= argLength;
								
								MemberValuePair lastMemberValuePair = memberValuePairs[memberValuePairs.length - 1];
								
								annotationEnd = 
									lastMemberValuePair.value != null
										? lastMemberValuePair.value instanceof Annotation
												? ((Annotation)lastMemberValuePair.value).declarationSourceEnd
												: lastMemberValuePair.value.sourceEnd
										: lastMemberValuePair.sourceEnd;
							}
							
							NormalAnnotation normalAnnotation = new NormalAnnotation(typeReference, this.sourceStart);
							normalAnnotation.memberValuePairs = memberValuePairs;
							normalAnnotation.declarationSourceEnd = annotationEnd;
							normalAnnotation.bits |= ASTNode.IsRecovered;
							
							annot = normalAnnotation;
							
							needUpdateRParenPos = true;
						}
					}
					
					
					break;
				case SINGLE_MEMBER:
					if (parser.expressionPtr > -1) {
						Expression memberValue = parser.expressionStack[parser.expressionPtr--];
						
						SingleMemberAnnotation singleMemberAnnotation = new SingleMemberAnnotation(typeReference, this.sourceStart);
						singleMemberAnnotation.memberValue = memberValue;
						singleMemberAnnotation.declarationSourceEnd = memberValue.sourceEnd;
						singleMemberAnnotation.bits |= ASTNode.IsRecovered;
						
						annot = singleMemberAnnotation;
							
						needUpdateRParenPos = true;
					}
					break;
			}
			
			if (!needUpdateRParenPos) {
				if (pendingMemberValueName != null) {
					NormalAnnotation normalAnnotation = new NormalAnnotation(typeReference, this.sourceStart);
					normalAnnotation.memberValuePairs = new MemberValuePair[]{pendingMemberValueName};
					normalAnnotation.declarationSourceEnd = pendingMemberValueName.value.sourceEnd;
					normalAnnotation.bits |= ASTNode.IsRecovered;
					
					annot = normalAnnotation;
				} else {
					MarkerAnnotation markerAnnotation = new MarkerAnnotation(typeReference, this.sourceStart);
					markerAnnotation.declarationSourceEnd = markerAnnotation.sourceEnd;
					markerAnnotation.bits |= ASTNode.IsRecovered;
					
					annot = markerAnnotation;
				}
			}
			
			parser.currentElement = this.addAnnotation(annot, this.identifierPtr);
			parser.annotationRecoveryCheckPoint(annot.sourceStart, annot.declarationSourceEnd);
			if (this.parent != null) {

				this.parent.updateFromParserState();
			}
		}
	}
	
	public ASTNode parseTree() {
		return this.annotation;
	}
	
	public void resetPendingModifiers() {
		if (parent != null) this.parent.resetPendingModifiers();
	}
	
	public void setKind(int kind) {
		this.kind = kind;
	}
	
	public int sourceEnd() {
		if (annotation == null) {
			Parser parser = parser();
			if (this.identifierPtr < parser.identifierPositionStack.length) {
				return (int) parser.identifierPositionStack[this.identifierPtr];
			} else {
				return this.sourceStart;
			}
		}
		return this.annotation.declarationSourceEnd;
	}
	
	public String toString(int tab) {	
		if (annotation != null) {
			return tabString(tab) + "Recovered annotation:\n" + annotation.print(tab + 1, new StringBuffer(10)); //$NON-NLS-1$
		} else {
			return tabString(tab) + "Recovered annotation: identiferPtr=" + this.identifierPtr + " identiferlengthPtr=" + this.identifierLengthPtr + "\n"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
	}
	
	public Annotation updatedAnnotationReference() {
		return this.annotation;
	}
	
	public RecoveredElement updateOnClosingBrace(int braceStart, int braceEnd){
		if (bracketBalance > 0){ // was an member value array initializer
			bracketBalance--;
			return this;
		}
		if (parent != null){
			return parent.updateOnClosingBrace(braceStart, braceEnd);
		}
		return this;
	}
	
	public void updateParseTree() {
		this.updatedAnnotationReference();
	}
}