qt/org.eclipse.cdt.qt.core/src/org/eclipse/cdt/internal/qt/core/QmlASTNodeHandler.java - cdt/org.eclipse.cdt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2015, 2016 QNX Software Systems 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:
  * QNX Software Systems - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.cdt.internal.qt.core;

 import java.lang.invoke.MethodHandles;
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import javax.script.Bindings;

 import org.eclipse.cdt.internal.qt.core.location.Position;
 import org.eclipse.cdt.internal.qt.core.location.SourceLocation;
 import org.eclipse.cdt.qt.core.IQMLAnalyzer;
 import org.eclipse.cdt.qt.core.location.ISourceLocation;
 import org.eclipse.cdt.qt.core.qmljs.IJSLiteral;
 import org.eclipse.cdt.qt.core.qmljs.IJSRegExpLiteral;
 import org.eclipse.cdt.qt.core.qmljs.IQmlASTNode;
 import org.eclipse.cdt.qt.core.qmljs.IQmlObjectDefinition;
 import org.eclipse.cdt.qt.core.qmljs.IQmlRootObject;

 /**
  * Translates a JavaScript {@link Bindings} object into a QML AST. This class employs {@link java.lang.reflect.Proxy} in order to
  * dynamically create the AST at runtime.
  * <p>
  * To begin translation simply call the static method <code>createQmlASTProxy</code>. The AST is translated only when it needs to be
  * (i.e. when one of its 'get' methods are called).
  */
 public class QmlASTNodeHandler implements InvocationHandler {
 	private static final String NODE_QML_PREFIX = "QML"; //$NON-NLS-1$
 	private static final String NODE_TYPE_PROPERTY = "type"; //$NON-NLS-1$
 	private static final String NODE_REGEX_PROPERTY = "regex"; //$NON-NLS-1$
 	private static final String CREATE_ENUM_METHOD = "fromObject"; //$NON-NLS-1$
 	private static final String AST_PACKAGE = "org.eclipse.cdt.qt.core.qmljs."; //$NON-NLS-1$
 	private static final String AST_QML_PREFIX = "IQml"; //$NON-NLS-1$
 	private static final String AST_JS_PREFIX = "IJS"; //$NON-NLS-1$

 	private static String getPropertyName(String method) {
 		String name = ""; //$NON-NLS-1$
 		if (method.startsWith("is")) { //$NON-NLS-1$
 			name = method.substring(2, 3).toLowerCase() + method.substring(3);
 		} else if (method.startsWith("get")) { //$NON-NLS-1$
 			name = method.substring(3, 4).toLowerCase() + method.substring(4);
 		}
 		if (name.equalsIgnoreCase("identifier")) { //$NON-NLS-1$
 			return "id"; //$NON-NLS-1$
 		} else if (name.equalsIgnoreCase("location")) { //$NON-NLS-1$
 			return "loc"; //$NON-NLS-1$
 		}
 		return name;
 	}

 	/**
 	 * Constructs a new {@link IQmlASTNode} from the given {@link Bindings}. This is a helper method equivalent to
 	 * <code>createQmlASTProxy(node, null)</code>
 	 *
 	 * @param node
 	 *            the AST node as retrieved from Nashorn
 	 * @return a Proxy representing the given node
 	 * @throws ClassNotFoundException
 	 *             if the node does not represent a valid QML AST Node
 	 * @see {@link QmlASTNodeHandler#createQmlASTProxy(Bindings, Class)}
 	 */
 	public static IQmlASTNode createQmlASTProxy(Bindings node) throws ClassNotFoundException {
 		return createQmlASTProxy(node, null);
 	}

 	/**
 	 * Constructs a new {@link IQmlASTNode} from the given {@link Bindings}. If a return type is specified, it will take precedence
 	 * over the type retrieved from the binding. This is useful for nodes that extend, but do not add functionality to, an acorn AST
 	 * element. A good example of this is {@link IQmlRootObject} which extends {@link IQmlObjectDefinition}. We can easily determine
 	 * the location in the AST at which we want an IQmlRootObject over an IQmlObjectDefinition and set the returnType accordingly.
 	 *
 	 * @param node
 	 *            the node as retrieved from acorn
 	 * @param returnType
 	 *            the expected node to return or null
 	 * @return a Proxy representing the given node
 	 * @throws ClassNotFoundException
 	 *             if the node does not represent a valid QML AST Node
 	 */
 	public static IQmlASTNode createQmlASTProxy(Bindings node, Class<?> returnType) throws ClassNotFoundException {
 		String type = (String) node.getOrDefault(NODE_TYPE_PROPERTY, ""); //$NON-NLS-1$
 		if (type.startsWith(NODE_QML_PREFIX)) {
 			type = AST_QML_PREFIX + type.substring(3);
 		} else {
 			type = AST_JS_PREFIX + type;
 		}
 		Class<?> astClass = Class.forName(AST_PACKAGE + type);
 		if (astClass.equals(IJSLiteral.class)) {
 			// If this is a Literal, we have to distinguish it between a RegExp Literal using the 'regex' property
 			if (node.get(NODE_REGEX_PROPERTY) != null) {
 				astClass = IJSRegExpLiteral.class;
 			}
 		}
 		if (returnType != null) {
 			if (!IQmlASTNode.class.isAssignableFrom(astClass)) {
 				throw new ClassCastException(astClass + " cannot be cast to " + IQmlASTNode.class); //$NON-NLS-1$
 			}
 			if (astClass.isAssignableFrom(returnType)) {
 				astClass = returnType;
 			}
 		}
 		return (IQmlASTNode) Proxy.newProxyInstance(QmlASTNodeHandler.class.getClassLoader(),
 				new Class<?>[] { astClass },
 				new QmlASTNodeHandler(node));
 	}

 	private final QMLAnalyzer analyzer;
 	private final Bindings node;
 	private final Map<String, Object> methodResults;

 	private QmlASTNodeHandler(Bindings node) {
 		this.analyzer = (QMLAnalyzer) Activator.getService(IQMLAnalyzer.class);
 		this.node = node;
 		this.methodResults = new HashMap<>();
 	}

 	@Override
 	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 		String mName = method.getName();
 		if (!methodResults.containsKey(method.getName())) {
 			// Invoke the default implementation of the method if possible
 			if (method.isDefault()) {
 				final Class<?> declaringClass = method.getDeclaringClass();
 				Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class,
 						int.class);
 				constructor.setAccessible(true);
 				methodResults.put(mName, constructor.newInstance(declaringClass, MethodHandles.Lookup.PRIVATE)
 						.unreflectSpecial(method, declaringClass)
 						.bindTo(proxy)
 						.invokeWithArguments(args));
 			} else {
 				// Use the return type of the method as well as its contents of the node to get the Object to return
 				String pName = getPropertyName(mName);
 				methodResults.put(mName, handleObject(node.get(pName), method.getReturnType()));
 			}
 		}
 		return methodResults.get(mName);
 	}

 	private Object handleObject(Object value, Class<?> expectedType) throws Throwable {
 		if (expectedType.isArray()) {
 			Object arr = Array.newInstance(expectedType.getComponentType(), ((Bindings) value).size());
 			int ctr = 0;
 			for (Object obj : ((Bindings) value).values()) {
 				Array.set(arr, ctr++, handleObject(obj, expectedType.getComponentType()));
 			}
 			return arr;
 		} else if (expectedType.equals(Object.class)) {
 			return value;
 		} else if (expectedType.isAssignableFrom(ISourceLocation.class)) {
 			// ISourceLocation doesn't correspond to an AST Node and needs to be created manually from
 			// the given Bindings.
 			if (value instanceof Bindings) {
 				Bindings bind = (Bindings) value;
 				SourceLocation loc = new SourceLocation();
 				loc.setSource((String) bind.get("source")); //$NON-NLS-1$
 				Bindings start = (Bindings) bind.get("start"); //$NON-NLS-1$
 				loc.setStart(new Position(((Number) start.get("line")).intValue(), //$NON-NLS-1$
 						((Number) start.get("column")).intValue())); //$NON-NLS-1$
 				Bindings end = (Bindings) bind.get("end"); //$NON-NLS-1$
 				loc.setEnd(new Position(((Number) end.get("line")).intValue(), //$NON-NLS-1$
 						((Number) end.get("column")).intValue())); //$NON-NLS-1$
 				return loc;
 			}
 			return new SourceLocation();
 		} else if (expectedType.isAssignableFrom(List.class)) {
 			if (value instanceof Bindings) {
 				List<Object> list = new ArrayList<>();
 				for (Bindings object : analyzer.toJavaArray((Bindings) value, Bindings[].class)) {
 					list.add(QmlASTNodeHandler.createQmlASTProxy(object));
 				}
 				return list;
 			}
 			return null;
 		} else if (expectedType.isPrimitive()) {
 			return handlePrimitive(value, expectedType);
 		} else if (expectedType.isAssignableFrom(Number.class)) {
 			if (value instanceof Number) {
 				return value;
 			}
 			return 0;
 		} else if (expectedType.isEnum()) {
 			return expectedType.getMethod(CREATE_ENUM_METHOD, Object.class).invoke(null, value);
 		} else if (value instanceof Bindings) {
 			return QmlASTNodeHandler.createQmlASTProxy((Bindings) value, expectedType);
 		}
 		return value;
 	}

 	private Object handlePrimitive(Object value, Class<?> expectedType) throws Throwable {
 		if (expectedType.isPrimitive()) {
 			if (expectedType.equals(Boolean.TYPE)) {
 				if (value instanceof Boolean) {
 					return value;
 				}
 				return false;
 			} else if (expectedType.equals(Character.TYPE)) {
 				if (value instanceof Character) {
 					return value;
 				}
 				return '\0';
 			} else if (expectedType.equals(Byte.TYPE)) {
 				if (value instanceof Number) {
 					return ((Number) value).byteValue();
 				}
 				return (byte) 0;
 			} else if (expectedType.equals(Short.TYPE)) {
 				if (value instanceof Number) {
 					return ((Number) value).shortValue();
 				}
 				return (short) 0;
 			} else if (expectedType.equals(Integer.TYPE)) {
 				if (value instanceof Number) {
 					return ((Number) value).intValue();
 				}
 				return 0;
 			} else if (expectedType.equals(Long.TYPE)) {
 				if (value instanceof Number) {
 					return ((Number) value).longValue();
 				}
 				return 0l;
 			} else if (expectedType.equals(Float.TYPE)) {
 				if (value instanceof Number) {
 					return ((Number) value).floatValue();
 				}
 				return 0.0f;
 			} else if (expectedType.equals(Double.TYPE)) {
 				if (value instanceof Number) {
 					return ((Number) value).doubleValue();
 				}
 				return 0.0d;
 			}
 		}
 		throw new IllegalArgumentException("expectedType was not a primitive type"); //$NON-NLS-1$
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2015, 2016 QNX Software Systems 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:
	* QNX Software Systems - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.cdt.internal.qt.core;

	import java.lang.invoke.MethodHandles;
	import java.lang.reflect.Array;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationHandler;
	import java.lang.reflect.Method;
	import java.lang.reflect.Proxy;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import javax.script.Bindings;

	import org.eclipse.cdt.internal.qt.core.location.Position;
	import org.eclipse.cdt.internal.qt.core.location.SourceLocation;
	import org.eclipse.cdt.qt.core.IQMLAnalyzer;
	import org.eclipse.cdt.qt.core.location.ISourceLocation;
	import org.eclipse.cdt.qt.core.qmljs.IJSLiteral;
	import org.eclipse.cdt.qt.core.qmljs.IJSRegExpLiteral;
	import org.eclipse.cdt.qt.core.qmljs.IQmlASTNode;
	import org.eclipse.cdt.qt.core.qmljs.IQmlObjectDefinition;
	import org.eclipse.cdt.qt.core.qmljs.IQmlRootObject;

	/**
	* Translates a JavaScript {@link Bindings} object into a QML AST. This class employs {@link java.lang.reflect.Proxy} in order to
	* dynamically create the AST at runtime.
	* <p>
	* To begin translation simply call the static method <code>createQmlASTProxy</code>. The AST is translated only when it needs to be
	* (i.e. when one of its 'get' methods are called).
	*/
	public class QmlASTNodeHandler implements InvocationHandler {
	private static final String NODE_QML_PREFIX = "QML"; //$NON-NLS-1$
	private static final String NODE_TYPE_PROPERTY = "type"; //$NON-NLS-1$
	private static final String NODE_REGEX_PROPERTY = "regex"; //$NON-NLS-1$
	private static final String CREATE_ENUM_METHOD = "fromObject"; //$NON-NLS-1$
	private static final String AST_PACKAGE = "org.eclipse.cdt.qt.core.qmljs."; //$NON-NLS-1$
	private static final String AST_QML_PREFIX = "IQml"; //$NON-NLS-1$
	private static final String AST_JS_PREFIX = "IJS"; //$NON-NLS-1$

	private static String getPropertyName(String method) {
	String name = ""; //$NON-NLS-1$
	if (method.startsWith("is")) { //$NON-NLS-1$
	name = method.substring(2, 3).toLowerCase() + method.substring(3);
	} else if (method.startsWith("get")) { //$NON-NLS-1$
	name = method.substring(3, 4).toLowerCase() + method.substring(4);
	}
	if (name.equalsIgnoreCase("identifier")) { //$NON-NLS-1$
	return "id"; //$NON-NLS-1$
	} else if (name.equalsIgnoreCase("location")) { //$NON-NLS-1$
	return "loc"; //$NON-NLS-1$
	}
	return name;
	}

	/**
	* Constructs a new {@link IQmlASTNode} from the given {@link Bindings}. This is a helper method equivalent to
	* <code>createQmlASTProxy(node, null)</code>
	*
	* @param node
	* the AST node as retrieved from Nashorn
	* @return a Proxy representing the given node
	* @throws ClassNotFoundException
	* if the node does not represent a valid QML AST Node
	* @see {@link QmlASTNodeHandler#createQmlASTProxy(Bindings, Class)}
	*/
	public static IQmlASTNode createQmlASTProxy(Bindings node) throws ClassNotFoundException {
	return createQmlASTProxy(node, null);
	}

	/**
	* Constructs a new {@link IQmlASTNode} from the given {@link Bindings}. If a return type is specified, it will take precedence
	* over the type retrieved from the binding. This is useful for nodes that extend, but do not add functionality to, an acorn AST
	* element. A good example of this is {@link IQmlRootObject} which extends {@link IQmlObjectDefinition}. We can easily determine
	* the location in the AST at which we want an IQmlRootObject over an IQmlObjectDefinition and set the returnType accordingly.
	*
	* @param node
	* the node as retrieved from acorn
	* @param returnType
	* the expected node to return or null
	* @return a Proxy representing the given node
	* @throws ClassNotFoundException
	* if the node does not represent a valid QML AST Node
	*/
	public static IQmlASTNode createQmlASTProxy(Bindings node, Class<?> returnType) throws ClassNotFoundException {
	String type = (String) node.getOrDefault(NODE_TYPE_PROPERTY, ""); //$NON-NLS-1$
	if (type.startsWith(NODE_QML_PREFIX)) {
	type = AST_QML_PREFIX + type.substring(3);
	} else {
	type = AST_JS_PREFIX + type;
	}
	Class<?> astClass = Class.forName(AST_PACKAGE + type);
	if (astClass.equals(IJSLiteral.class)) {
	// If this is a Literal, we have to distinguish it between a RegExp Literal using the 'regex' property
	if (node.get(NODE_REGEX_PROPERTY) != null) {
	astClass = IJSRegExpLiteral.class;
	}
	}
	if (returnType != null) {
	if (!IQmlASTNode.class.isAssignableFrom(astClass)) {
	throw new ClassCastException(astClass + " cannot be cast to " + IQmlASTNode.class); //$NON-NLS-1$
	}
	if (astClass.isAssignableFrom(returnType)) {
	astClass = returnType;
	}
	}
	return (IQmlASTNode) Proxy.newProxyInstance(QmlASTNodeHandler.class.getClassLoader(),
	new Class<?>[] { astClass },
	new QmlASTNodeHandler(node));
	}

	private final QMLAnalyzer analyzer;
	private final Bindings node;
	private final Map<String, Object> methodResults;

	private QmlASTNodeHandler(Bindings node) {
	this.analyzer = (QMLAnalyzer) Activator.getService(IQMLAnalyzer.class);
	this.node = node;
	this.methodResults = new HashMap<>();
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	String mName = method.getName();
	if (!methodResults.containsKey(method.getName())) {
	// Invoke the default implementation of the method if possible
	if (method.isDefault()) {
	final Class<?> declaringClass = method.getDeclaringClass();
	Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class,
	int.class);
	constructor.setAccessible(true);
	methodResults.put(mName, constructor.newInstance(declaringClass, MethodHandles.Lookup.PRIVATE)
	.unreflectSpecial(method, declaringClass)
	.bindTo(proxy)
	.invokeWithArguments(args));
	} else {
	// Use the return type of the method as well as its contents of the node to get the Object to return
	String pName = getPropertyName(mName);
	methodResults.put(mName, handleObject(node.get(pName), method.getReturnType()));
	}
	}
	return methodResults.get(mName);
	}

	private Object handleObject(Object value, Class<?> expectedType) throws Throwable {
	if (expectedType.isArray()) {
	Object arr = Array.newInstance(expectedType.getComponentType(), ((Bindings) value).size());
	int ctr = 0;
	for (Object obj : ((Bindings) value).values()) {
	Array.set(arr, ctr++, handleObject(obj, expectedType.getComponentType()));
	}
	return arr;
	} else if (expectedType.equals(Object.class)) {
	return value;
	} else if (expectedType.isAssignableFrom(ISourceLocation.class)) {
	// ISourceLocation doesn't correspond to an AST Node and needs to be created manually from
	// the given Bindings.
	if (value instanceof Bindings) {
	Bindings bind = (Bindings) value;
	SourceLocation loc = new SourceLocation();
	loc.setSource((String) bind.get("source")); //$NON-NLS-1$
	Bindings start = (Bindings) bind.get("start"); //$NON-NLS-1$
	loc.setStart(new Position(((Number) start.get("line")).intValue(), //$NON-NLS-1$
	((Number) start.get("column")).intValue())); //$NON-NLS-1$
	Bindings end = (Bindings) bind.get("end"); //$NON-NLS-1$
	loc.setEnd(new Position(((Number) end.get("line")).intValue(), //$NON-NLS-1$
	((Number) end.get("column")).intValue())); //$NON-NLS-1$
	return loc;
	}
	return new SourceLocation();
	} else if (expectedType.isAssignableFrom(List.class)) {
	if (value instanceof Bindings) {
	List<Object> list = new ArrayList<>();
	for (Bindings object : analyzer.toJavaArray((Bindings) value, Bindings[].class)) {
	list.add(QmlASTNodeHandler.createQmlASTProxy(object));
	}
	return list;
	}
	return null;
	} else if (expectedType.isPrimitive()) {
	return handlePrimitive(value, expectedType);
	} else if (expectedType.isAssignableFrom(Number.class)) {
	if (value instanceof Number) {
	return value;
	}
	return 0;
	} else if (expectedType.isEnum()) {
	return expectedType.getMethod(CREATE_ENUM_METHOD, Object.class).invoke(null, value);
	} else if (value instanceof Bindings) {
	return QmlASTNodeHandler.createQmlASTProxy((Bindings) value, expectedType);
	}
	return value;
	}

	private Object handlePrimitive(Object value, Class<?> expectedType) throws Throwable {
	if (expectedType.isPrimitive()) {
	if (expectedType.equals(Boolean.TYPE)) {
	if (value instanceof Boolean) {
	return value;
	}
	return false;
	} else if (expectedType.equals(Character.TYPE)) {
	if (value instanceof Character) {
	return value;
	}
	return '\0';
	} else if (expectedType.equals(Byte.TYPE)) {
	if (value instanceof Number) {
	return ((Number) value).byteValue();
	}
	return (byte) 0;
	} else if (expectedType.equals(Short.TYPE)) {
	if (value instanceof Number) {
	return ((Number) value).shortValue();
	}
	return (short) 0;
	} else if (expectedType.equals(Integer.TYPE)) {
	if (value instanceof Number) {
	return ((Number) value).intValue();
	}
	return 0;
	} else if (expectedType.equals(Long.TYPE)) {
	if (value instanceof Number) {
	return ((Number) value).longValue();
	}
	return 0l;
	} else if (expectedType.equals(Float.TYPE)) {
	if (value instanceof Number) {
	return ((Number) value).floatValue();
	}
	return 0.0f;
	} else if (expectedType.equals(Double.TYPE)) {
	if (value instanceof Number) {
	return ((Number) value).doubleValue();
	}
	return 0.0d;
	}
	}
	throw new IllegalArgumentException("expectedType was not a primitive type"); //$NON-NLS-1$
	}
	}