qt/org.eclipse.cdt.qt.core/src/org/eclipse/cdt/internal/qt/core/QtMethodReference.java

/*
 * Copyright (c) 2014, 2015 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
 */
package org.eclipse.cdt.internal.qt.core;

import java.util.regex.Matcher;

import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTMacroExpansionLocation;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTNodeLocation;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorMacroDefinition;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorMacroExpansion;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPSemantics;
import org.eclipse.cdt.internal.qt.core.index.IQMethod;
import org.eclipse.cdt.internal.qt.core.index.IQObject;
import org.eclipse.cdt.internal.qt.core.index.QtIndex;
import org.eclipse.cdt.internal.qt.core.pdom.ASTNameReference;
import org.eclipse.cdt.internal.qt.core.pdom.QtASTImageLocation;
import org.eclipse.core.resources.IProject;

/**
 * Qt signals and slots are referenced using the SIGNAL and SLOT macros.  The expansion
 * parameter is the signature of the signal or slot and they are associated with a type.
 * This utility class is used to convert from these AST nodes to an IASTName that can be
 * used as a reference to the IBinding for the C++ method.
 */
@SuppressWarnings("restriction")
public class QtMethodReference extends ASTNameReference {

	public static enum Type {
		Signal("sender", "SIGNAL", "signal"),
		Slot("receiver", "SLOT", "member");

		public final String roleName;
		public final String macroName;
		public final String paramName;

		public boolean matches(Type other) {
			if (other == null)
				return false;

			// The signal parameter must be a SIGNAL, but the slot could be a
			// SLOT or a SIGNAL.
			return this == Signal ? other == Signal : true;
		}

		/**
		 * Return the type of method reference within the expansion of the given macro name.
		 */
		public static Type from(IASTName name) {
			String nameStr = String.valueOf(name);
			if (QtKeywords.SIGNAL.equals(nameStr))
				return Signal;
			if (QtKeywords.SLOT.equals(nameStr))
				return Slot;
			return null;
		}

		private Type(String roleName, String macroName, String paramName) {
			this.roleName = roleName;
			this.macroName = macroName;
			this.paramName = paramName;
		}
	}

	private final Type type;
	private final ICPPClassType cls;
	private final String expansionParam;

	private QtMethodReference(Type type, ICPPClassType cls, IASTName macroRefName, String expansionParam, IASTFileLocation location) {
		super(macroRefName, location);

		this.type = type;
		this.cls = cls;
		this.expansionParam = expansionParam;
	}

	/**
	 * Return the C++ class that defines the Qt method that is being referenced.
	 */
	public ICPPClassType getContainingType() {
		return cls;
	}

	/**
	 * Look for SIGNAL or SLOT macro expansions at the location of the given node.  Return the
	 * QMethod reference is an expansion is found and null otherwise.
	 * <p>
	 * QMetaMethod references cannot be statically resolved so null will be returned in this case.
	 */
	public static QtMethodReference parse(IASTNode parent, IType cppType, IASTNode arg) {
		if (!(cppType instanceof ICPPClassType) || arg == null)
			return null;
		ICPPClassType cls = (ICPPClassType) cppType;

		// Look for a SIGNAL or SLOT expansion as this location.
		Type type = null;
		IASTName macroReferenceName = null;
		for(IASTNodeLocation location : arg.getNodeLocations()) {
			if (!(location instanceof IASTMacroExpansionLocation))
				continue;

			IASTPreprocessorMacroExpansion expansion = ((IASTMacroExpansionLocation) location).getExpansion();
			macroReferenceName = expansion.getMacroReference();
			IASTPreprocessorMacroDefinition macroDefn = expansion.getMacroDefinition();

			type = Type.from(macroDefn.getName());
			if (type != null)
				break;
		}

		// There is nothing to do if the expected type of expansion is not found.
		if (macroReferenceName == null || type == null)
			return null;

		// This check will miss cases like:
		//     #define MY_SIG1 SIGNAL
		//     #define MY_SIG2(s) SIGNAL(s)
		//     #define MY_SIG3(s) SIGNAL(signal())
		//     connect( &a, MY_SIG1(signal()), ...
		//     connect( &a, MY_SIG2(signal()), ...
		//     connect( &a, MY_SIG2, ...
		// This could be improved by adding tests when arg represents a macro expansion.  However, I'm
		// not sure if we would be able to follow the more complicated case of macros that call functions
		// that use the SIGNAL macro.  For now I've implemented the simpler check of forcing the call to
		// use the SIGNAL/SLOT macro directly.
		String raw = arg.getRawSignature();
		Matcher m = ASTUtil.Regex_MacroExpansion.matcher( raw );
		if( ! m.matches() )
			return null;

		// Get the argument to the SIGNAL/SLOT macro and the offset/length of that argument within the
		// complete function argument.  E.g., with this argument to QObject::connect
		//      SIGNAL( signal(int) )
		// the values are
		//		expansionArgs:  "signal(int)"
		//		expansionOffset: 8
		//		expansionLength: 11
		String expansionArgs = m.group( 2 );
		int expansionOffset = m.start( 2 );
		int expansionLength = m.end( 2 ) - expansionOffset;

		IASTFileLocation location = new QtASTImageLocation(macroReferenceName.getFileLocation(), expansionOffset, expansionLength);
		return new QtMethodReference(type, cls, macroReferenceName, expansionArgs, location);
	}

	public Type getType() {
		return type;
	}

	@Override
	public String getRawSignature() {
		return expansionParam;
	}

	@Override
	public char[] getSimpleID() {
		return expansionParam.toCharArray();
	}

	private IQObject findQObject() {
		String[] qualName = null;
		try {
			qualName = cls.getQualifiedName();
		} catch(DOMException e) {
			Activator.log(e);
		}

		IProject project = ASTUtil.getProject(delegate);
		if (project == null)
			return null;

		QtIndex qtIndex = QtIndex.getIndex(project);
		if (qtIndex == null)
			return null;

		return qtIndex.findQObject(qualName);
	}

	public IQMethod getMethod() {
		IQObject qobj = findQObject();
		if (qobj == null)
			return null;

		// Return the first matching method.
		for(IQMethod method : ASTUtil.findMethods(qobj, this))
			return method;

		return null;
	}

	@Override
	public IBinding resolveBinding() {
		if (binding != null)
			return binding;

		// Qt method references return the C++ method that is being referenced in the SIGNAL or
		// SLOT macro expansion.
		String methodName = expansionParam;
		int paren = methodName.indexOf('(');
		if (paren > 0)
			methodName = methodName.substring(0, paren);
		IBinding[] methods = CPPSemantics.findBindings(cls.getCompositeScope(), methodName.trim(), false);

		// TODO find the one binding that matches the parameter of the macro expansion
		// 1) Normalize expansionParam
		// 2) Use it to filter the matching methods
		binding = methods.length > 0 ? methods[0] : null;
		return binding;
	}
}