path: root/qt/org.eclipse.cdt.qt.core/src/org/eclipse/cdt/internal/qt/core/pdom/QtASTVisitor.java

/*
 * Copyright (c) 2013 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.pdom;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTFunctionCallExpression;
import org.eclipse.cdt.core.dom.ast.IASTIdExpression;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorIncludeStatement;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorMacroDefinition;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorMacroExpansion;
import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.index.IIndexSymbols;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalBinding;
import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPSemantics;
import org.eclipse.cdt.internal.core.parser.scanner.LocationMap;
import org.eclipse.cdt.internal.qt.core.ASTUtil;
import org.eclipse.cdt.internal.qt.core.QtFunctionCall;
import org.eclipse.cdt.internal.qt.core.QtMethodReference;
import org.eclipse.cdt.internal.qt.core.QtMethodUtil;
import org.eclipse.cdt.internal.qt.core.index.QProperty;
import org.eclipse.cdt.qt.core.QtKeywords;
import org.eclipse.cdt.qt.core.index.IQMethod;
import org.eclipse.cdt.qt.core.index.IQProperty;

@SuppressWarnings("restriction")
public class QtASTVisitor extends ASTVisitor {

	private final IIndexSymbols symbols;
	private final LocationMap locationMap;

	private static final Pattern expansionParamRegex = Pattern.compile("^(?:Q_ENUMS|Q_FLAGS)\\s*\\((.*)\\)$", Pattern.DOTALL);
	private static final Pattern qualNameRegex = Pattern.compile("\\s*((?:[^\\s:]+\\s*::\\s*)*[^\\s:]+).*");

	private static final Pattern declareFlagsRegex = Pattern.compile("^Q_DECLARE_FLAGS\\s*\\(\\s*([^\\s]+),\\s*([^\\s]+)\\s*\\)$", Pattern.DOTALL);

	/**
	 * A regular expression for scanning the Q_CLASSINFO expansion and extracting the
	 * expansion parameter key and value.  It provides the following capture groups:
	 * <br>1 - the key
	 * <br>2 - the value
	 * <p>
	 * The key must not have embedded quotes.
	 */
	private static final Pattern classInfoRegex = Pattern.compile("^Q_CLASSINFO\\s*\\(\\s*\"([^\"]+)\"\\s*,\\s*\"(.*)\"\\s*\\)$", Pattern.DOTALL);

	private static final Pattern leadingWhitespaceRegex = Pattern.compile("^\\s*([^\\s].*)$");

	private static final Pattern qPropertyRegex = Pattern.compile("^Q_PROPERTY\\s*\\(\\s*(.+?)\\s*([a-zA-Z_][\\w]*+)(?:(?:\\s+(READ\\s+.*))|\\s*)\\s*\\)$", Pattern.DOTALL);

	/**
	 * A regular expression for scanning Q_PROPERTY attributes.  The regular expression is built
	 * from the values defined in IQProperty#Attribute.  It looks like:
	 * <pre>
	 * (:?READ)|(?:WRITE)|(:?RESET)|...
	 * </pre>
	 * This regular expression is used to recognize valid attributes while scanning the
	 * Q_PROPERTY macro expansion.
	 *
	 * @see QProperty#scanAttributes(String)
	 */
	private static final Pattern qPropertyAttributeRegex;
	static {
		StringBuilder regexBuilder = new StringBuilder();
		for(IQProperty.Attribute attr : IQProperty.Attribute.values()) {
			if (attr.ordinal() > 0)
				regexBuilder.append('|');
			regexBuilder.append("(:?");
			regexBuilder.append(attr.identifier);
			regexBuilder.append(")");
		}
		qPropertyAttributeRegex = Pattern.compile(regexBuilder.toString());
	}

	public QtASTVisitor(IIndexSymbols symbols, LocationMap locationMap) {
		shouldVisitDeclSpecifiers = true;
		shouldVisitExpressions = true;

		this.symbols = symbols;
		this.locationMap = locationMap;
	}

	@Override
	public int visit(IASTDeclSpecifier declSpec) {
		if (declSpec instanceof ICPPASTCompositeTypeSpecifier) {
			ICPPASTCompositeTypeSpecifier spec = (ICPPASTCompositeTypeSpecifier) declSpec;

			IASTFileLocation loc = spec.getFileLocation();
			IASTPreprocessorIncludeStatement owner = loc == null ? null : loc.getContextInclusionStatement();

			IASTPreprocessorMacroExpansion[] expansions = locationMap.getMacroExpansions(loc);

			if (isQObject(spec, expansions))
				handleQObject(owner, spec, expansions);
			if (isQGadget(spec, expansions))
				handleQClass(owner, spec, new QGadgetName(spec), expansions);
		}

		return super.visit(declSpec);
	}

	@Override
	public int visit(IASTExpression expr) {
		if (expr instanceof IASTFunctionCallExpression) {
			IASTFunctionCallExpression call = (IASTFunctionCallExpression) expr;

			// See if this is a QObject::connect or disconnect function call.
			Collection<QtMethodReference> refs = QtFunctionCall.getReferences(call);
			if (refs != null)
				for (IASTName ref : refs) {
					IASTFileLocation nameLoc = ref.getFileLocation();
					if (nameLoc != null) {
						IASTPreprocessorIncludeStatement owner = nameLoc.getContextInclusionStatement();
						symbols.add(owner, ref, null);
					}
				}

			// See if this is a qmlRegisterType or qmlRegisterUncreatableType function call.
			ICPPTemplateInstance templateFn = ASTUtil.resolveFunctionBinding(ICPPTemplateInstance.class, call);
			if (QtKeywords.is_QmlType(templateFn)) {
				IASTName fnName = null;
				IASTExpression fnNameExpr = call.getFunctionNameExpression();
				if (fnNameExpr instanceof IASTIdExpression) {
					fnName = ((IASTIdExpression) fnNameExpr).getName();
				}
				IASTFileLocation nameLoc = call.getFileLocation();
				if (nameLoc != null) {
					QmlTypeRegistration qmlTypeReg = new QmlTypeRegistration(fnName, templateFn, call);

					IASTPreprocessorIncludeStatement owner = nameLoc.getContextInclusionStatement();
					symbols.add(owner, qmlTypeReg, null);

					// the Qt data references the C++ function template instance specialization
					if (fnName != null)
						symbols.add(owner, new ASTNameReference(fnName), qmlTypeReg);
				}
			}
		}

		return super.visit(expr);
	}

	private boolean isQObject(ICPPASTCompositeTypeSpecifier spec, IASTPreprocessorMacroExpansion[] expansions) {

		// The class definition must contain a Q_OBJECT expansion.
		for (IASTPreprocessorMacroExpansion expansion : expansions) {
			IASTPreprocessorMacroDefinition macro = expansion.getMacroDefinition();
			if (QtKeywords.Q_OBJECT.equals(String.valueOf(macro.getName())))
				return true;
		}

		return false;
	}

	private boolean isQGadget(ICPPASTCompositeTypeSpecifier spec, IASTPreprocessorMacroExpansion[] expansions) {

		// The class definition must contain a Q_GADGET expansion.
		for (IASTPreprocessorMacroExpansion expansion : expansions) {
			IASTPreprocessorMacroDefinition macro = expansion.getMacroDefinition();
			if (QtKeywords.Q_GADGET.equals(String.valueOf(macro.getName())))
				return true;
		}

		return false;
	}

	private class EnumDecl {
		private final String name;
		private final boolean isFlag;
		private final IASTName refName;
		private final QtASTImageLocation location;

		public EnumDecl(String name, boolean isFlag, IASTName refName, int offset, int length) {
			this.name = name;
			this.isFlag = isFlag;
			this.refName = refName;
			this.location = new QtASTImageLocation(refName.getFileLocation(), offset, length);
		}

		public void handle(IASTPreprocessorIncludeStatement owner, ICPPASTCompositeTypeSpecifier spec, IQtASTName qobjName, Map<String, String> aliases) {

			String alias = aliases.get(name);

			IBinding[] bindings = CPPSemantics.findBindingsForQualifiedName(spec.getScope(), alias == null ? name : alias);
			for(IBinding binding : bindings) {
				// Create a reference from this Qt name to the target enum's definition.
				IASTName cppName = findASTName(binding);
				QtEnumName astName = new QtEnumName(qobjName, refName, name, cppName, location, isFlag);
				symbols.add(owner, astName, qobjName);

				if (cppName != null)
					symbols.add(owner, new ASTNameReference(cppName, location), astName);
			}
		}
	}

	private void handleQObject(IASTPreprocessorIncludeStatement owner, ICPPASTCompositeTypeSpecifier spec, IASTPreprocessorMacroExpansion[] expansions) {

		// Put the QObject into the symbol map.
		QObjectName qobjName = new QObjectName(spec);
		handleQClass(owner, spec, qobjName, expansions);

		for (IASTPreprocessorMacroExpansion expansion : expansions) {

			IASTName name = expansion.getMacroReference();
			String macroName = name == null ? null : name.toString();
			if (QtKeywords.Q_OBJECT.equals(macroName))
				continue;

			if(QtKeywords.Q_CLASSINFO.equals(macroName)) {
				Matcher m = classInfoRegex.matcher(expansion.getRawSignature());
				if (m.matches()) {
					String key = m.group(1);
					String value = m.group(2);
					qobjName.addClassInfo(key, value);
				}
			} else if(QtKeywords.Q_PROPERTY.equals(macroName))
				handleQPropertyDefn(owner, qobjName, expansion);
		}

		// Process the slot, signal, and invokable method declarations.
		extractQMethods(owner, spec, qobjName);
	}

	private void handleQClass(IASTPreprocessorIncludeStatement owner, ICPPASTCompositeTypeSpecifier spec, IQtASTName qtName, IASTPreprocessorMacroExpansion[] expansions) {

		// Put the Qt name into the symbol map.
		symbols.add(owner, qtName, null);

		// The QClass contains a reference to the C++ class that it annotates.
		symbols.add(owner, new ASTNameReference(spec.getName()), qtName);

		// There are three macros that are significant to QEnums, Q_ENUMS, Q_FLAGS, and Q_DECLARE_FLAGS.
		// All macro expansions in the QObject class definition are examined to find instances of these
		// three.  Two lists are created during this processing.  Then those lists are uses to create
		// the QEnum instances.

		List<EnumDecl> enumDecls = new ArrayList<QtASTVisitor.EnumDecl>();
		Map<String, String> flagAliases = new HashMap<String, String>();

		for (IASTPreprocessorMacroExpansion expansion : expansions) {

			IASTName name = expansion.getMacroReference();
			String macroName = name == null ? null : name.toString();
			if (QtKeywords.Q_OBJECT.equals(macroName))
				continue;

			if (QtKeywords.Q_ENUMS.equals(macroName))
				extractEnumDecls(expansion, false, enumDecls);
			else if (QtKeywords.Q_FLAGS.equals(macroName))
				extractEnumDecls(expansion, true, enumDecls);
			else if (QtKeywords.Q_DECLARE_FLAGS.equals(macroName)) {
				Matcher m = declareFlagsRegex.matcher(expansion.getRawSignature());
				if (m.matches()) {
					String flagName = m.group(1);
					String enumName = m.group(2);
					flagAliases.put(flagName, enumName);
				}
			}
		}

		for(EnumDecl decl : enumDecls)
			decl.handle(owner, spec, qtName, flagAliases);
	}

	private void extractEnumDecls(IASTPreprocessorMacroExpansion expansion, boolean isFlag, List<EnumDecl> decls) {
		String signature = expansion.getRawSignature();
		Matcher m = expansionParamRegex.matcher(signature);
		if (!m.matches())
			return;

		IASTName refName = expansion.getMacroReference();
		String param = m.group(1);
		for(int offset = m.start(1), end = param.length(); !param.isEmpty(); offset += end, param = param.substring(end)) {
			m = qualNameRegex.matcher(param);
			if (!m.matches())
				break;

			int start = m.start(1);
			end = m.end(1);

			String enumName = m.group(1);
			decls.add(new EnumDecl(enumName, isFlag, refName, offset + start, end - start));
		}
	}

	private void handleQPropertyDefn(IASTPreprocessorIncludeStatement owner, QObjectName qobjName, IASTPreprocessorMacroExpansion expansion) {
		Matcher m = qPropertyRegex.matcher(expansion.getRawSignature());
		if (!m.matches())
			return;

		String type = m.group(1);
		String name = m.group(2);

		int nameStart = m.start(2);
		int nameEnd = m.end(2);

		IASTName refName = expansion.getMacroReference();
		QtASTImageLocation location = new QtASTImageLocation(refName.getFileLocation(), nameStart, nameEnd - nameStart);

		QtPropertyName propertyName = new QtPropertyName(qobjName, refName, name, location);
		propertyName.setType(type);
		qobjName.addProperty(propertyName);
		symbols.add(owner, propertyName, qobjName);

		// Create nodes for all the attributes.
		AttrValue[] values = new AttrValue[IQProperty.Attribute.values().length];
		String attributes = m.group(3);
		if (attributes == null)
			return;

		int attrOffset = m.start(3);

		int lastEnd = 0;
		IQProperty.Attribute lastAttr = null;
		for(Matcher attributeMatcher = qPropertyAttributeRegex.matcher(attributes); attributeMatcher.find(); lastEnd = attributeMatcher.end()) {
			// set the value of attribute found in the previous iteration to the substring between
			// the end of that attribute and the start of this one
			if (lastAttr != null) {
				String value = attributes.substring(lastEnd, attributeMatcher.start());
				int wsOffset = 0;
				Matcher ws = leadingWhitespaceRegex.matcher(value);
				if (ws.matches()) {
					value = ws.group(1);
					wsOffset = ws.start(1);
				}

				values[lastAttr.ordinal()] = new AttrValue(attrOffset + lastEnd + wsOffset, value.trim());
			}

			// the regex is built from the definition of the enum, so none of the strings that it
			// finds will throw an exception
			lastAttr = IQProperty.Attribute.valueOf(IQProperty.Attribute.class, attributeMatcher.group(0));

			// if this attribute doesn't have a value, then put it into the value map immediately
			// and make sure it is not used later in this scan
			if (!lastAttr.hasValue) {
				values[lastAttr.ordinal()] = AttrValue.None;
				lastAttr = null;
			}
		}

		// the value of the last attribute in the expansion is the substring between the end of
		// the attribute identifier and the end of the string
		if (lastAttr != null) {
			String value = attributes.substring(lastEnd);
			int wsOffset = 0;
			Matcher ws = leadingWhitespaceRegex.matcher(value);
			if (ws.matches()) {
				value = ws.group(1);
				wsOffset = ws.start(1);
			}

			values[lastAttr.ordinal()] = new AttrValue(attrOffset + lastEnd + wsOffset, value.trim());
		}

		// Put all values into the property name.
		for(int i = 0; i < values.length; ++i) {
			IQProperty.Attribute attr = IQProperty.Attribute.values()[i];
			AttrValue value = values[i];
			if (value == null)
				continue;

			// If the attribute is not expected to have a C++ binding as the value, then it can
			// be immediately added to the Q_PROPERTY.
			if (!couldHaveBinding(attr)) {
				propertyName.addAttribute(attr, value.value);
				continue;
			}

			// Otherwise see if one or more bindings can be found for the value of the attribute.
			// TODO Check whether the Qt moc allows for inherited methods.
			IBinding[] bindings = null;
			IASTNode specNode = qobjName.getParent();
			if (specNode instanceof IASTCompositeTypeSpecifier) {
				IScope scope = ((IASTCompositeTypeSpecifier) specNode).getScope();
				bindings = CPPSemantics.findBindings(scope, value.value, false);
			}

			// If no bindings are found, then the attribute can be immediately added to the Q_PROPERTY.
			if (bindings == null || bindings.length <= 0) {
				propertyName.addAttribute(attr, value.value);
				continue;
			}

			// Otherwise create a new attribute for each binding.
			for(IBinding foundBinding : bindings) {
				propertyName.addAttribute(attr, value.value, foundBinding);

				IASTName cppName = findASTName(foundBinding);
				if (cppName != null) {
					QtASTImageLocation attrLoc = new QtASTImageLocation(refName.getFileLocation(), value.offset, value.value.length());
					symbols.add(owner, new ASTNameReference(cppName, attrLoc), propertyName);
				}
			}
		}
	}

	private static boolean couldHaveBinding(IQProperty.Attribute attr) {
		switch(attr) {
		case READ:
		case WRITE:
		case RESET:
		case NOTIFY:
		case DESIGNABLE:
		case SCRIPTABLE:
			return true;

		case REVISION:
		case STORED:
		case USER:
		case CONSTANT:
		case FINAL:
		default:
			return false;
		}
	}

	private static IASTName findASTName(IBinding binding) {
		IASTNode node = null;
		if (binding instanceof ICPPInternalBinding) {
			node = ((ICPPInternalBinding) binding).getDefinition();
			if (node == null)
				node = ((ICPPInternalBinding) binding).getDeclarations()[0];
		}

		if (node == null)
			return null;

		IASTName astName = node instanceof IASTName ? (IASTName) node : null;
		if (astName != null)
			return astName;

		if (node instanceof IASTDeclarator)
			return ((IASTDeclarator) node).getName();

		return null;
	}

	private static class AttrValue {
		public final int offset;
		public final String value;
		public AttrValue(int offset, String value) {
			this.offset = offset;
			this.value = value;
		}
		public static final AttrValue None = new AttrValue(0, null);
	}

	private void extractQMethods(IASTPreprocessorIncludeStatement owner, ICPPASTCompositeTypeSpecifier spec, QObjectName qobjName) {
		QtASTClass qtASTClass = QtASTClass.create(spec);
		for (IASTDeclaration decl : spec.getMembers()) {

			// We only care about this node if it is within a signal/slot region or if it
			// has been tagged with a Qt annotating tag.
			int offset = decl.getFileLocation().getNodeOffset();
			IQMethod.Kind kind = qtASTClass.getKindFor(offset);
			Long revision = qtASTClass.getRevisionFor(offset);
			if (kind == IQMethod.Kind.Unspecified)
				continue;

			// Only named methods are processed, so skip this node if it is not a function or
			// if it does not have a name.
			IASTSimpleDeclaration simpleDecl = getSimpleDecl(decl);
			if (simpleDecl == null)
				continue;

			ICPPASTFunctionDeclarator decltor = null;
			for(IASTDeclarator d : simpleDecl.getDeclarators())
				if (d instanceof ICPPASTFunctionDeclarator) {
					decltor = (ICPPASTFunctionDeclarator) d;
					break;
				}
			if (decltor == null)
				continue;

			IASTName cppName = decltor.getName();
			if (cppName == null)
				continue;

			String qtEncSignatures = QtMethodUtil.getEncodedQtMethodSignatures(decltor);
			symbols.add(owner, new QMethodName(qobjName, cppName, kind, qtEncSignatures, revision), qobjName);
		}
	}

	private static IASTSimpleDeclaration getSimpleDecl(IASTNode node) {
		while (node != null && !(node instanceof IASTSimpleDeclaration))
			node = node.getParent();
		return node instanceof IASTSimpleDeclaration ? (IASTSimpleDeclaration) node : null;
	}
}