KeywordChecks.java

/*
 * 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.syntaxChecks;

import static lombok.ast.syntaxChecks.MessageKey.*;
import static lombok.ast.Message.*;

import java.util.List;
import java.util.Map;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;

import lombok.ast.AnnotationDeclaration;
import lombok.ast.AnnotationMethodDeclaration;
import lombok.ast.ClassDeclaration;
import lombok.ast.CompilationUnit;
import lombok.ast.EmptyDeclaration;
import lombok.ast.EnumDeclaration;
import lombok.ast.InterfaceDeclaration;
import lombok.ast.KeywordModifier;
import lombok.ast.MethodDeclaration;
import lombok.ast.Modifiers;
import lombok.ast.Node;
import lombok.ast.StaticInitializer;
import lombok.ast.TypeDeclaration;
import lombok.ast.VariableDeclaration;
import lombok.ast.VariableDefinition;
import lombok.ast.VariableDefinitionEntry;
import lombok.ast.template.SyntaxCheck;

@SyntaxCheck
public class KeywordChecks {
	private static final int K_PUBLIC       = 0x0001;
	private static final int K_PRIVATE      = 0x0002;
	private static final int K_PROTECTED    = 0x0004;
	private static final int K_STATIC       = 0x0008;
	private static final int K_FINAL        = 0x0010;
	private static final int K_SYNCHRONIZED = 0x0020;
	private static final int K_VOLATILE     = 0x0040;
	private static final int K_TRANSIENT    = 0x0080;
	private static final int K_NATIVE       = 0x0100;
	private static final int K_ABSTRACT     = 0x0400;
	private static final int K_STRICTFP     = 0x0800;
	private static final Map<String, Integer> TO_FLAG_MAP = ImmutableMap.<String, Integer>builder()
		.put("private", K_PRIVATE)
		.put("protected", K_PROTECTED)
		.put("public", K_PUBLIC)
		.put("final", K_FINAL)
		.put("native", K_NATIVE)
		.put("strictfp", K_STRICTFP)
		.put("synchronized", K_SYNCHRONIZED)
		.put("abstract", K_ABSTRACT)
		.put("static", K_STATIC)
		.put("transient", K_TRANSIENT)
		.put("volatile", K_VOLATILE)
		.build();
	
	private static final int[] METHOD_MODIFIERS_EXCLUSIVITY = {
		K_PRIVATE   | K_PROTECTED,
		K_PRIVATE   | K_PUBLIC,
		K_PROTECTED | K_PUBLIC,
		K_NATIVE    | K_STRICTFP,
		K_ABSTRACT  | K_FINAL,
		K_ABSTRACT  | K_NATIVE,
		K_ABSTRACT  | K_STATIC,
		K_ABSTRACT  | K_STRICTFP,
		K_ABSTRACT  | K_SYNCHRONIZED,
	};
	
	private static final int METHOD_MODIFIERS_LEGAL =
		K_PRIVATE | K_PROTECTED | K_PUBLIC | K_ABSTRACT | K_FINAL | K_NATIVE |
		K_STATIC | K_STRICTFP | K_SYNCHRONIZED
	;
	
	private static final int[] FIELD_MODIFIERS_EXCLUSIVITY = {
		K_PRIVATE | K_PROTECTED,
		K_PRIVATE | K_PUBLIC,
		K_PROTECTED | K_PUBLIC,
		K_VOLATILE | K_FINAL,
	};
	
	private static final int FIELD_MODIFIERS_LEGAL =
		K_PRIVATE | K_PROTECTED | K_PUBLIC | K_STATIC | K_FINAL | K_TRANSIENT | K_VOLATILE;
	
	private static final int[] TYPE_MODIFIERS_EXCLUSIVITY = {
		K_PRIVATE | K_PROTECTED,
		K_PRIVATE | K_PUBLIC,
		K_PROTECTED | K_PUBLIC,
		K_FINAL | K_ABSTRACT,
	};
	
	private static final int TYPE_MODIFIERS_LEGAL =
		K_PRIVATE | K_PROTECTED | K_PUBLIC | K_STATIC | K_FINAL | K_ABSTRACT | K_STRICTFP;
	
	public void duplicateKeywordModifierCheck(Modifiers modifiers) {
		List<String> keywords = Lists.newArrayList();
		
		for (KeywordModifier n : modifiers.astKeywords()) {
			String k = n.astName();
			if (k != null && !k.isEmpty() ) {
				if (keywords.contains(k)) {
					n.addMessage(error(MODIFIERS_DUPLICATE_KEYWORD, "Duplicate modifier: " + k));
				} else {
					keywords.add(k);
				}
			}
		}
	}
	
	public void methodModifiersCheck(MethodDeclaration md) {
		modifiersCheck(md.astModifiers(),
				METHOD_MODIFIERS_EXCLUSIVITY, METHOD_MODIFIERS_LEGAL, "method declarations");
		checkStaticChain(md.astModifiers());
	}
	
	public void annotationMethodModifiersCheck(AnnotationMethodDeclaration md) {
		modifiersCheck(md.astModifiers(),
				METHOD_MODIFIERS_EXCLUSIVITY, METHOD_MODIFIERS_LEGAL & ~K_STRICTFP,
				"annotation method declarations");
		checkStaticChain(md.astModifiers());
	}
	
	public void fieldModifiersCheck(VariableDeclaration vd) {
		TypeDeclaration td = vd.upUpToTypeDeclaration();
		if (td == null) return;	//not a field.
		VariableDefinition def = vd.astDefinition();
		if (def != null) {
			Modifiers m = def.astModifiers();
			modifiersCheck(m, FIELD_MODIFIERS_EXCLUSIVITY, FIELD_MODIFIERS_LEGAL, "field declarations");
			boolean allFieldsHaveInitializers = true;
			for (VariableDefinitionEntry entry : def.astVariables()) {
				if (entry.rawInitializer() == null) {
					allFieldsHaveInitializers = false;
					break;
				}
			}
			
			if (m.isStatic() && !m.isFinal() && !allFieldsHaveInitializers) {
				// Initialized static final fields, assuming the initializer expression is a compile time constant, are 'special' and
				// do not need to adhere to the static chain rule. However, we can't determine CTC nature without resolution.
				checkStaticChain(m);
			}
		}
	}
	
	public void localVariableModifiersCheck(VariableDefinition vd) {
		boolean applies = vd.upUpIfLocalVariableToBlock() != null;
		if (!applies) applies = vd.upToForEach() != null;
		if (!applies) applies = vd.upToFor() != null;
		if (!applies) return;
		
		modifiersCheck(vd.astModifiers(), new int[0], K_FINAL, "local variable declarations");
	}
	
	public void classDeclarationModifiersCheck(ClassDeclaration cd) {
		typeModifiersCheck(cd, "class declarations");
	}
	
	public void interfaceDeclarationModifiersCheck(InterfaceDeclaration id) {
		int flags = typeModifiersCheck(id, "interface declarations");
		generateNotAllowedKeywordError(id.astModifiers(), flags, K_FINAL, "final", "Interfaces cannot be final");
	}
	
	public void annotationDeclarationModifiersCheck(AnnotationDeclaration ad) {
		int flags = typeModifiersCheck(ad, "annotation declarations");
		generateNotAllowedKeywordError(ad.astModifiers(), flags, K_FINAL, "final", "Annotations cannot be final");
	}
	
	public void enumDeclarationModifiersCheck(EnumDeclaration ad) {
		int flags = typeModifiersCheck(ad, "enum declarations");
		generateNotAllowedKeywordError(ad.astModifiers(), flags, K_FINAL, "final", "Enums cannot be marked final");
	}
	
	private int typeModifiersCheck(TypeDeclaration td, String desc) {
		int flags = modifiersCheck(td.astModifiers(),
				TYPE_MODIFIERS_EXCLUSIVITY, TYPE_MODIFIERS_LEGAL, desc);
		boolean staticWarningEmitted = false;
		if (td.upIfTopLevelToCompilationUnit() != null) {
			generateNotAllowedKeywordError(td.astModifiers(), flags, K_PRIVATE, "private", "Top-level types cannot be private.");
			staticWarningEmitted |= generateNotAllowedKeywordError(td.astModifiers(), flags, K_STATIC, "static", "Top-level types cannot be static.");
		} else if (td.upToBlock() != null) {
			generateNotAllowedKeywordError(td.astModifiers(), flags, K_PRIVATE, "private", "Method-local types cannot be private.");
			generateNotAllowedKeywordError(td.astModifiers(), flags, K_PROTECTED, "protected", "Method-local types cannot be protected.");
			generateNotAllowedKeywordError(td.astModifiers(), flags, K_PUBLIC, "public", "Method-local types cannot be public.");
			staticWarningEmitted |= generateNotAllowedKeywordError(td.astModifiers(), flags, K_STATIC, "static", "Method-local types cannot be static.");
		}
		
		if (!staticWarningEmitted) checkStaticChain(td.astModifiers());
		
		return flags;
	}
	
	public void checkStaticInitializerInNonStaticType(StaticInitializer node) {
		TypeDeclaration parent = node.upUpToTypeDeclaration();
		if (parent != null) {
			if (!parent.astModifiers().isStatic()) {
				node.addMessage(error(INITIALIZER_STATIC_IN_NON_STATIC_TYPE,
						"static initializers are only allowed in top-level or static types declarations."));
			}
		}
	}
	
	private void checkStaticChain(Modifiers modifiers) {
		if (!modifiers.isStatic()) return;
		
		Node p = modifiers.getParent();
		while (p != null) {
			if (p instanceof CompilationUnit) return;
			if (p instanceof TypeDeclaration) {
				Modifiers pMods = ((TypeDeclaration)p).astModifiers();
				if (!pMods.isStatic()) {
					modifiers.getParent().addMessage(error(MODIFIERS_STATIC_CHAIN,
							"This declaration is (effectively) static; static declarations or only legal in top-level and static declarations."));
				}
			}
			p = p.getParent();
		}
	}
	
	private int modifiersCheck(Modifiers modifiers, int[] exclusivity, int legality, String desc) {
		int flags = modifiers.getEffectiveModifierFlags();
		int implicits = flags & ~modifiers.getExplicitModifierFlags();
		
		for (Node n : modifiers.rawKeywords()) {
			if (n instanceof KeywordModifier) {
				String k = ((KeywordModifier)n).astName();
				if (k == null || k.isEmpty()) {
					n.addMessage(error(MODIFIERS_EMPTY_MODIFIER, "Empty/null modifier."));
				}
				
				if (!TO_FLAG_MAP.containsKey(k)) {
					n.addMessage(error(MODIFIERS_UNKNOWN_MODIFIER, "Unknown modifier: " + k));
					continue;
				}
				
				int flag = TO_FLAG_MAP.get(k);
				if ((legality & flag) == 0) {
					n.addMessage(error(MODIFIERS_MODIFIER_NOT_ALLOWED, "Modifier not allowed on " + desc + ": " + k));
					continue;
				}
				
				flags |= flag;
			}
		}
		
		for (int exclusive : exclusivity) {
			if ((flags & exclusive) == exclusive) {
				generateExclusivityError(implicits, exclusive, modifiers);
			}
		}
		
		return flags;
	}
	
	private boolean generateNotAllowedKeywordError(Modifiers modifiers, int flags, int flag, String keyword, String error) {
		if ((flags & flag) == 0) return false;
		
		for (KeywordModifier n : modifiers.astKeywords()) {
			if (keyword.equals(n.astName())) {
				n.addMessage(error(MODIFIERS_MODIFIER_NOT_ALLOWED, error));
				return true;
			}
		}
		
		return false;
	}
	
	public void emptyDeclarationMustHaveNoModifiers(EmptyDeclaration node) {
		Modifiers modifiers = node.astModifiers();
		
		if (!modifiers.astKeywords().isEmpty() || !modifiers.astAnnotations().isEmpty()) {
			node.addMessage(error(MODIFIERS_MODIFIER_NOT_ALLOWED, "Empty Declarations cannot have modifiers."));
		}
	}
	
	private void generateExclusivityError(int implicit, int exclusive, Modifiers modifiers) {
		String hit = null;
		
		int responsibleImplicit = implicit & exclusive;
		
		if (responsibleImplicit != 0) {
			String nameOfResponsibleImplicit = "(unknown)";
			for (Map.Entry<String, Integer> x : TO_FLAG_MAP.entrySet()) {
				if (x.getValue() == responsibleImplicit) nameOfResponsibleImplicit = x.getKey();
			}
			
			for (Node n : modifiers.rawKeywords()) {
				if (n instanceof KeywordModifier) {
					String k = ((KeywordModifier)n).astName();
					if (!TO_FLAG_MAP.containsKey(k)) continue;
					int f = TO_FLAG_MAP.get(k);
					if ((f & exclusive) == 0) continue;
					
					modifiers.addMessage(error(MODIFIERS_MODIFIER_CONFLICT, String.format(
							"Modifier %s cannot be used here; it is already implicitly %s.", k, nameOfResponsibleImplicit)));
				}
			}
		} else {
			for (Node n : modifiers.rawKeywords()) {
				if (n instanceof KeywordModifier) {
					String k = ((KeywordModifier)n).astName();
					if (!TO_FLAG_MAP.containsKey(k)) continue;
					int f = TO_FLAG_MAP.get(k);
					if ((f & exclusive) == 0) continue;
					
					if (hit == null) {
						hit = k;
						continue;
					}
					
					modifiers.addMessage(error(MODIFIERS_MODIFIER_CONFLICT, String.format(
							"Modifier %s cannot be used together with %s here.", k, hit)));
				}
			}
		}
	}
}