org.walkmod.javalang.compiler.reflection.FieldInspector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javalang-compiler Show documentation
Library of compiler components to processs Java code.
There is a newer version: 2.3.10
/*
 Copyright (C) 2015 Raquel Pau and Albert Coroleu.
 
Walkmod is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Walkmod is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with Walkmod.  If not, see .*/
package org.walkmod.javalang.compiler.reflection;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.walkmod.javalang.compiler.symbols.SymbolTable;
import org.walkmod.javalang.compiler.symbols.SymbolType;
import org.walkmod.javalang.exceptions.NoSuchExpressionTypeException;

public class FieldInspector {

	public static Set getNonPrivateFields(Class clazz) {
		Set result = new HashSet();
		if (clazz == null || clazz.equals(Object.class)) {
			return result;
		}
		Field[] fields = clazz.getDeclaredFields();

		for (int i = 0; i < fields.length; i++) {
			if (!Modifier.isPrivate(fields[i].getModifiers())) {
				result.add(fields[i]);
			}
		}
		result.addAll(getNonPrivateFields(clazz.getSuperclass()));
		Class[] interfaces = clazz.getInterfaces();
		for (int i = 0; i < interfaces.length; i++) {
			result.addAll(getNonPrivateFields(interfaces[i]));
		}
		return result;
	}

	public static SymbolType findFieldType(SymbolTable symTable, SymbolType scope, String fieldName) {

		SymbolType result = null;
		if (scope != null) {
			List> classes = scope.getBoundClasses();
			Iterator> it = classes.iterator();

			while (it.hasNext() && result == null) {
				try {
					Class clazz = it.next();

					Field field = null;
					if (scope.getArrayCount() > 0 && fieldName.equals("length")) {
						result = new SymbolType("int");
					} else {
						try {
							field = clazz.getDeclaredField(fieldName);

						} catch (NoSuchFieldException fe) {

							field = getField0(clazz.getPackage(), clazz, fieldName);
							if (field == null) {
								// check a field with no visibility
								SymbolType st = symTable.getType("this");

								Class internal = ClassInspector.findClassMember(st.getClazz().getPackage(),
										fieldName, clazz);
								if (internal != null) {
									result = new SymbolType(internal);
								}

							}
						}
						if (result == null && field != null) {
							Map typeMapping = new HashMap();

							Class container = field.getDeclaringClass();

							if (!container.getName().equals(clazz.getName())) {
								Set equivalentTypeImplementations = ClassInspector
										.getEquivalentParametrizableClasses(clazz);
								if (equivalentTypeImplementations != null) {
									Iterator itTypes = equivalentTypeImplementations.iterator();
									while (itTypes.hasNext()) {
										java.lang.reflect.Type current = itTypes.next();
										if (current instanceof ParameterizedType) {
											ParameterizedType paramType = (ParameterizedType) current;
											java.lang.reflect.Type rawType = paramType.getRawType();
											if (rawType instanceof Class) {
												String raw = ((Class) paramType.getRawType()).getName();
												if (raw.equals(container.getName())) {

													scope = SymbolType.valueOf(current, typeMapping);
												}
											}
										}
									}
								}
							}

							GenericBuilderFromGenericClasses builder = new GenericBuilderFromGenericClasses(container,
									scope.getParameterizedTypes());

							builder.build(typeMapping);

							result = SymbolType.valueOf(field.getGenericType(), typeMapping);
							result.setField(field);
						}
					}
				} catch (Exception e) {
					throw new NoSuchExpressionTypeException(e);

				}
			}
		}
		if (result == null) {
			throw new RuntimeException("The field " + fieldName + " is not found");
		}
		return result;
	}

	private static Field getField0(Package pkg, Class clazz, String name) {

		Field res = null;
		try {
			res = clazz.getDeclaredField(name);
		} catch (NoSuchFieldException e) {

		}
		// Search declared public fields
		if (res != null) {
			int modifiers = res.getModifiers();
			if (Modifier.isPublic(modifiers)) {
				return res;
			} else if (Modifier.isProtected(modifiers)) {
				return res;
			} else if (!Modifier.isPrivate(modifiers) && res.getDeclaringClass().getPackage().equals(pkg)) {
				return res;
			}
		}
		// Direct superinterfaces, recursively
		Class[] interfaces = clazz.getInterfaces();
		for (int i = 0; i < interfaces.length; i++) {
			Class c = interfaces[i];
			if ((res = getField0(pkg, c, name)) != null) {
				return res;
			}
		}
		// Direct superclass, recursively
		if (!clazz.isInterface()) {
			Class c = clazz.getSuperclass();
			if (c != null) {
				if ((res = getField0(pkg, c, name)) != null) {
					return res;
				}
			}
		}
		return null;
	}
}