tcl/plugins/org.eclipse.dltk.tcl.core/src/org/eclipse/dltk/tcl/internal/core/codeassist/TclSelectionEngine.java

/*******************************************************************************
 * Copyright (c) 2005, 2017 IBM Corporation 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.dltk.tcl.internal.core.codeassist;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.ASTVisitor;
import org.eclipse.dltk.ast.declarations.Argument;
import org.eclipse.dltk.ast.declarations.FieldDeclaration;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
import org.eclipse.dltk.ast.declarations.TypeDeclaration;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.references.SimpleReference;
import org.eclipse.dltk.ast.statements.Block;
import org.eclipse.dltk.codeassist.AssistParser;
import org.eclipse.dltk.codeassist.IAssistParser;
import org.eclipse.dltk.codeassist.ScriptSelectionEngine;
import org.eclipse.dltk.compiler.env.IModuleSource;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IParent;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.mixin.IMixinElement;
import org.eclipse.dltk.core.mixin.IMixinRequestor;
import org.eclipse.dltk.internal.codeassist.select.SelectionNodeFound;
import org.eclipse.dltk.tcl.ast.ITclStatementLookLike;
import org.eclipse.dltk.tcl.ast.TclStatement;
import org.eclipse.dltk.tcl.core.TclLanguageToolkit;
import org.eclipse.dltk.tcl.core.TclParseUtil;
import org.eclipse.dltk.tcl.core.extensions.ISelectionExtension;
import org.eclipse.dltk.tcl.internal.core.TclExtensionManager;
import org.eclipse.dltk.tcl.internal.core.codeassist.TclResolver.IResolveElementParent;
import org.eclipse.dltk.tcl.internal.core.codeassist.selection.SelectionOnAST;
import org.eclipse.dltk.tcl.internal.core.codeassist.selection.SelectionOnKeywordOrFunction;
import org.eclipse.dltk.tcl.internal.core.codeassist.selection.SelectionOnNode;
import org.eclipse.dltk.tcl.internal.core.codeassist.selection.SelectionOnVariable;
import org.eclipse.dltk.tcl.internal.core.packages.TclBuildPathPackageCollector;
import org.eclipse.dltk.tcl.internal.core.search.mixin.TclMixinModel;
import org.eclipse.dltk.tcl.internal.core.search.mixin.model.TclField;
import org.eclipse.dltk.tcl.internal.core.search.mixin.model.TclNamespaceImport;
import org.eclipse.dltk.tcl.internal.core.search.mixin.model.TclProc;
import org.eclipse.dltk.tcl.internal.parser.OldTclParserUtils;

public class TclSelectionEngine extends ScriptSelectionEngine {
	public static boolean DEBUG = DLTKCore.DEBUG_SELECTION;

	protected int actualSelectionStart;

	protected int actualSelectionEnd;

	protected List<IModelElement> selectionElements = new ArrayList<>();

	protected AssistParser parser = new AssistParser(new TclSelectionParser());

	protected org.eclipse.dltk.core.ISourceModule sourceModule;

	protected IDLTKLanguageToolkit toolkit;

	protected ISelectionExtension[] extensions;

	private TclBuildPathPackageCollector packageCollector;

	public TclSelectionEngine() {
		this.toolkit = TclLanguageToolkit.getDefault();
		this.extensions = TclExtensionManager.getDefault()
				.getSelectionExtensions();
	}

	@Override
	public IModelElement[] select(IModuleSource sourceUnit,
			int selectionSourceStart, int selectionSourceEnd) {
		sourceModule = (org.eclipse.dltk.core.ISourceModule) sourceUnit
				.getModelElement();
		String content = sourceUnit.getSourceContents();

		if (DEBUG) {
			System.out.print("SELECTION IN "); //$NON-NLS-1$
			System.out.print(sourceUnit.getFileName());
			System.out.print(" FROM "); //$NON-NLS-1$
			System.out.print(selectionSourceStart);
			System.out.print(" TO "); //$NON-NLS-1$
			System.out.println(selectionSourceEnd);
			System.out.println("SELECTION - Source :"); //$NON-NLS-1$
			System.out.println(content);
		}

		if (!checkSelection(content, selectionSourceStart,
				selectionSourceEnd)) {
			return new IModelElement[0];
		}

		if (DEBUG) {
			System.out.print("SELECTION - Checked : \""); //$NON-NLS-1$
			System.out.print(content.substring(actualSelectionStart,
					actualSelectionEnd));
			System.out.println('"');
		}

		try {
			ModuleDeclaration parsedUnit = this.parser.parse(sourceUnit);
			packageCollector = new TclBuildPathPackageCollector();
			try {
				parsedUnit.traverse(packageCollector);
			} catch (Exception e1) {
				if (DLTKCore.DEBUG) {
					e1.printStackTrace();
				}
			}

			if (parsedUnit != null) {
				try {
					parser.parseBlockStatements(parsedUnit,
							this.actualSelectionStart);
					if (DEBUG) {
						System.out.println("COMPLETION - AST :"); //$NON-NLS-1$
						System.out.println(parsedUnit.toString());
					}
				} catch (SelectionNodeFound e) {
					// completionNodeFound = true;
					if (e.getNode() != null) {
						if (DEBUG) {
							System.out.print("COMPLETION - Completion node : "); //$NON-NLS-1$
							System.out.println(e.getNode().toString());
							if (this.parser.getAssistNodeParent() != null) {
								System.out.print("COMPLETION - Parent Node : "); //$NON-NLS-1$
								System.out.println(
										this.parser.getAssistNodeParent());
							}
						}
						// if null then we found a problem in the completion
						// node
						select(e.getNode(), this.parser.getAssistNodeParent());
					}
				}
			}
		} catch (IndexOutOfBoundsException e) { // work-around internal failure
			// - 1GEMF6D
			if (DEBUG) {
				System.out.println("Exception caught by SelectionEngine:"); //$NON-NLS-1$
				e.printStackTrace(System.out);
			}
		}

		return selectionElements
				.toArray(new IModelElement[selectionElements.size()]);
	}

	protected ASTNode parseBlockStatements(TypeDeclaration type,
			ModuleDeclaration unit, int position) {
		ASTNode result = parser.parseBlockStatements(type, unit, position);
		if (result != null) {
			return result;
		}
		if (type instanceof ITclStatementLookLike) {
			TclStatement statement = ((ITclStatementLookLike) type)
					.getStatement();
			ASTNode inNode = TclParseUtil.getScopeParent(parser.getModule(),
					type);
			this.getAssistParser().parseBlockStatements(statement, inNode,
					position);
			SelectionOnNode nde = new SelectionOnNode(type);
			nde.setPosition(position);
			throw new SelectionNodeFound(nde);
		}
		return null;
	}

	protected void select(ASTNode astNode, ASTNode astNodeParent) {
		if (astNode instanceof SelectionOnKeywordOrFunction) {
			SelectionOnKeywordOrFunction key = (SelectionOnKeywordOrFunction) astNode;
			// findKeywords(key.getToken(), key.getPossibleKeywords(),
			// key.canCompleteEmptyToken());

			String name = key.getName();
			if (name != null) {
				findLocalFunctions(name, astNodeParent);
				if (this.selectionElements.size() > 0) {
					return;
				}
				findMethodFromMixin(name);
				// findMethodFromSearch(name);
				// if (this.selectionElements.size() > 0) {
				// return;
				// }
				String fqnName = null;
				if (astNodeParent instanceof TypeDeclaration) {
					TypeDeclaration t = (TypeDeclaration) astNodeParent;
					fqnName = t.getEnclosingTypeName() + "::" + t.getName()
							+ "::" + name;
				} else if (astNodeParent instanceof MethodDeclaration) {
					MethodDeclaration t = (MethodDeclaration) astNodeParent;
					fqnName = t.getDeclaringTypeName() + "::" + name;
				}
				if (fqnName != null) {
					if (!fqnName.startsWith("::"))
						fqnName = "::" + fqnName;
					findMethodFromMixin(name);
					// findMethodFromSearch(fqnName);
				}
				// Search in imported namespaces
				String currentNamespace = TclParseUtil.getElementFQN(
						astNodeParent, "::", getAssistParser().getModule());
				Set processed = new HashSet();
				selectNamespaceImport(name, currentNamespace, processed);
				if (!currentNamespace.equals("")) {
					selectNamespaceImport(name, "", processed);
				}
			}
			for (int i = 0; i < this.extensions.length; i++) {
				this.extensions[i].selectionOnKeywordOrFunction(key, this);
			}
		} else if (astNode instanceof SelectionOnVariable) {
			SelectionOnVariable completion = (SelectionOnVariable) astNode;
			findVariables(completion.getName(), astNodeParent,
					astNode.sourceStart());
		} else if (astNode instanceof SelectionOnAST) {
			ASTNode node = ((SelectionOnAST) astNode).getNode();
			for (int i = 0; i < this.extensions.length; i++) {
				this.extensions[i].selectionOnAST(node, this);
			}
			addElementFromASTNode(node);
		} else if (astNode instanceof SelectionOnNode) {
			ASTNode node = ((SelectionOnNode) astNode).getNode();
			int position = ((SelectionOnNode) astNode).getPosition();
			for (int i = 0; i < this.extensions.length; i++) {
				this.extensions[i].selectionOnNode(node, position, this);
			}
		}
	}

	private void selectNamespaceImport(String name, String currentNamespace,
			Set processed) {
		String pattern = "@" + currentNamespace + "|*";
		String[] findKeys = TclMixinModel.getInstance()
				.getMixin(getScriptProject()).findKeys(pattern);
		Set keys = new HashSet();
		for (int i = 0; i < findKeys.length; i++) {
			if (keys.add(findKeys[i])) {
				TclNamespaceImport importSt = TclNamespaceImport
						.parseKey(findKeys[i]);
				if (importSt.getNamespace().equals(currentNamespace)) {
					if (processed.add(importSt.getImportNsName())) {
						findMethodFromMixinNS(
								importSt.getImportNsName() + "::" + name,
								importSt.getImportNsName());
					}
				}
			}
		}
	}

	protected void findMethodFromMixin(String name) {
		if (name.startsWith("::")) {
			if (name.startsWith("::")) {
				name = name.substring(2);
			}
		}
		String oName = name;
		if (name.indexOf("::") != -1) {
			String[] split = TclParseUtil.tclSplit(name);
			oName = split[split.length - 1];
		}
		findMethodMixin(tclNameToKey(name), oName);
	}

	protected void findMethodFromMixinNS(String name, String namespace) {
		if (name.startsWith("::")) {
			if (name.startsWith("::")) {
				name = name.substring(2);
			}
		}
		String oName = name;
		if (name.indexOf("::") != -1) {
			String[] split = TclParseUtil.tclSplit(name);
			oName = split[split.length - 1];
		}
		findMethodMixinNS(tclNameToKey(name), oName, namespace);
	}

	public boolean checkMethodFrom(TypeDeclaration declaringType,
			SimpleReference callName, IModelElement parent) {
		List methodList = declaringType.getMethodList();
		for (Iterator iterator = methodList.iterator(); iterator.hasNext();) {
			MethodDeclaration method = (MethodDeclaration) iterator.next();
			if (method.getName().equals(callName.toString())) {

				IModelElement methodElement = TclResolver
						.findChildrenByName(method.getName(), (IParent) parent);
				addSelectionElement(methodElement);
				return true;
			}
		}
		return false;
	}

	public void fillSuperClassesTo(TypeDeclaration declaringType,
			List supersToHandle) {
		if (declaringType == null) {
			return;
		}
		if (declaringType.getSuperClasses() == null) {
			return;
		}
		List superClasses = declaringType.getSuperClasses().getChilds();
		for (int i = 0; i < superClasses.size(); i++) {
			String superClassName = TclParseUtil
					.getNameFromNode((ASTNode) superClasses.get(i));
			if (superClassName != null) {
				supersToHandle.add(superClassName);
			}
		}
	}

	protected void findVariables(String name, ASTNode parent,
			int beforePosition) {
		String originalName = name;

		for (int i = 0; i < this.extensions.length; i++) {
			this.extensions[i].findVariables(name, parent, beforePosition,
					this);
			if (this.selectionElements.size() > 0) {
				return;
			}
		}

		if (parent instanceof MethodDeclaration) {
			MethodDeclaration method = (MethodDeclaration) parent;
			List statements = method.getArguments();
			if (statements != null) {
				for (int i = 0; i < statements.size(); ++i) {
					Argument a = (Argument) statements.get(i);
					if (a != null) {
						checkVariable(name, a.getName(), method);
					}
				}
			}
			// Process variable setters.
			statements = method.getStatements();
			checkVariableStatements(name, beforePosition, statements, "");
		} else if (parent instanceof ModuleDeclaration) {
			ModuleDeclaration module = (ModuleDeclaration) parent;
			checkVariableStatements(name, beforePosition,
					module.getStatements(), "");
		} else if (parent instanceof TypeDeclaration) {
			TypeDeclaration type = (TypeDeclaration) parent;
			checkVariableStatements(name, beforePosition, type.getStatements(),
					"");
		} else {
			List levels = TclParseUtil.findLevelsTo(this.parser.getModule(),
					parent);
			ASTNode realParent = findRealParent(levels);
			if (realParent != null) {
				findVariables(name, realParent, beforePosition);
			}
		}
		if (this.selectionElements.size() > 0) {
			return;
		}
		// Find global variables
		if (name.startsWith("$")) {
			name = name.substring(1);
			if (!name.startsWith("::")) {
				name = "::" + name;
			}
			String typeName = name.substring(0, name.lastIndexOf("::"));
			String varName = name.substring(name.lastIndexOf("::") + 2);
			typeName = typeName.replaceAll("::", "\\$");
			try {
				IModelElement type = null;
				if (typeName.length() > 0) {
					type = (IModelElement) TclResolver.findTypeFrom(
							sourceModule.getChildren(), "", typeName, '$');
				} else {
					type = this.sourceModule;
				}
				if (type != null && type instanceof IParent) {
					IModelElement field = TclResolver
							.findChildrenByName(varName, (IParent) type);
					if (field != null) {
						addSelectionElement(field);
					}
				}
			} catch (ModelException e) {
				if (DLTKCore.DEBUG) {
					e.printStackTrace();
				}
			}
			// findFieldFromSearch(name);
			findFieldFromMixin(parent, name);
		}
		if (this.selectionElements.size() > 0) {
			return;
		}
		// Search from mixins if not found local.
		findFieldFromMixin(parent, originalName);

	}

	protected void findFieldFromMixin(ASTNode parent, String name) {

		// findFieldMixin(IMixinRequestor.MIXIN_NAME_SEPARATOR +
		// tclNameToKey(name), name);
		if (name.startsWith("$")) {
			name = name.substring(1);
		}
		if (name.startsWith("{") || name.endsWith("}")) {
			name = name.substring(1, name.length() - 1);
		}
		if (parent instanceof ModuleDeclaration || name.startsWith("::")) {
			if (name.startsWith("::")) {
				name = name.substring(2);
			}
			String oName = name;
			if (name.indexOf("::") != -1) {
				String[] split = TclParseUtil.tclSplit(name);
				oName = split[split.length - 1];
			}
			findFieldMixin(tclNameToKey(name), oName);
		} else {
			List levels = TclParseUtil.findLevelsTo(this.parser.getModule(),
					parent);
			String keyFromLevels = getKeyFromLevels(levels);
			findFieldMixin(
					keyFromLevels + IMixinRequestor.MIXIN_NAME_SEPARATOR + name,
					name);
		}
	}

	public String tclNameToKey(String name) {
		return TclParseUtil.tclNameTo(name,
				IMixinRequestor.MIXIN_NAME_SEPARATOR);
	}

	protected void findFieldMixin(String pattern, String name) {
		IMixinElement[] find = TclMixinModel.getInstance()
				.getMixin(this.sourceModule.getScriptProject()).find(pattern);
		for (int i = 0; i < find.length; i++) {
			Object[] allObjects = find[i].getAllObjects();
			for (int j = 0; j < allObjects.length; j++) {
				if (allObjects[j] != null
						&& allObjects[j] instanceof TclField) {
					TclField field = (TclField) allObjects[j];
					if (name.equals(field.getName())) {
						addSelectionElement(field.getModelElement());
						return;
					}
				}
			}
		}
	}

	public void findMethodMixin(String pattern, String name) {
		IMixinElement[] find = TclMixinModel.getInstance()
				.getMixin(this.sourceModule.getScriptProject()).find(pattern);
		List<IModelElement> selections = new ArrayList<>();
		for (int i = 0; i < find.length; i++) {
			Object[] allObjects = find[i].getAllObjects();
			for (int j = 0; j < allObjects.length; j++) {
				if (allObjects[j] != null && allObjects[j] instanceof TclProc) {
					TclProc field = (TclProc) allObjects[j];
					if (name.equals(field.getName())) {
						// addSelectionElement(field.getModelElement());
						selections.add(field.getModelElement());
						// return;
					}
				}
			}
		}
		IModelElement result[] = TclResolver.complexFilter(
				selections.toArray(new IModelElement[selections.size()]),
				this.getScriptProject(), this.packageCollector, true);
		for (int i = 0; i < result.length; i++) {
			addSelectionElement(result[i]);
		}
	}

	public void findMethodMixinNS(String pattern, String name,
			String namespace) {
		if (!namespace.startsWith("::")) {
			namespace = "::" + namespace;
		}
		if (!namespace.endsWith("::")) {
			namespace = namespace + "::";
		}
		IMixinElement[] find = TclMixinModel.getInstance()
				.getMixin(this.sourceModule.getScriptProject()).find(pattern);
		for (int i = 0; i < find.length; i++) {
			Object[] allObjects = find[i].getAllObjects();
			for (int j = 0; j < allObjects.length; j++) {
				if (allObjects[j] != null && allObjects[j] instanceof TclProc) {
					TclProc field = (TclProc) allObjects[j];
					if (name.equals(field.getName())) {
						IModelElement element = field.getModelElement();

						String fqn = TclParseUtil
								.getFQNFromModelElement(element, "::");
						if (fqn.startsWith(namespace)) {
							String substring = fqn
									.substring(namespace.length());
							if (substring.indexOf("::") == -1) {
								addSelectionElement(element);
							}
						} else {
							addSelectionElement(element);
						}
						return;
					}
				}
			}
		}
	}

	protected String getKeyFromLevels(List nodes) {
		return TclParseUtil.getElementFQN(nodes,
				IMixinRequestor.MIXIN_NAME_SEPARATOR, this.parser.getModule());
	}

	protected ASTNode findRealParent(List levels) {
		for (int i = levels.size() - 1; i >= 0; --i) {
			ASTNode n = (ASTNode) levels.get(i);
			if (n instanceof MethodDeclaration || n instanceof TypeDeclaration
					|| n instanceof ModuleDeclaration) {
				return n;
			}
		}
		return null;
	}

	protected void checkVariableStatements(String name, int beforePosition,
			List statements, String prefix) {
		if (statements != null) {
			for (int i = 0; i < statements.size(); ++i) {
				ASTNode node = (ASTNode) statements.get(i);
				if (node instanceof FieldDeclaration) {
					FieldDeclaration decl = (FieldDeclaration) node;
					checkVariable(name, prefix + decl.getName(), node);
				}
				if (node instanceof TclStatement
						&& node.sourceEnd() < beforePosition) {
					TclStatement s = (TclStatement) node;
					String[] variable = OldTclParserUtils.returnVariable(s);
					if (variable != null) {
						for (int u = 0; u < variable.length; ++u) {
							checkVariable(name, prefix + variable[u], node);
						}
					}
				}
				if (node instanceof TypeDeclaration) {
					TypeDeclaration type = (TypeDeclaration) node;
					String nn = type.getName();
					if (nn.startsWith("::")) {
						nn = nn.substring(2);
					}
					// TODO: Possible bug with adding to global namespace from
					// inner namespace.
					checkVariableStatements(name, beforePosition,
							type.getStatements(), prefix + nn + "::");
					// checkVariableStatements(name, beforePosition, type
					// .getStatements(), "");
				}
				// This is in case not of type declaration
				else if (node.sourceStart() <= beforePosition) {
					List statements2 = TclResolver.findExtractBlocks(node);
					if (statements2.size() != 0) {
						checkVariableStatements(name, beforePosition,
								statements2, prefix);
					}
				}
			}
		}
	}

	private void checkVariable(String name, String variable, ASTNode node) {
		String str;
		if (variable.indexOf('(') != -1) {
			variable = variable.substring(0, variable.indexOf('('));
		}
		if (name.startsWith("${")) {
			str = "$" + '{' + variable + '}';
		} else {
			str = "$" + variable;
		}
		// strip array indexes
		if (name.indexOf('(') != -1) {
			name = name.substring(0, name.indexOf('('));
		}

		if (name.equals(str)) {
			addElementFromASTNode(node);
		}
	}

	protected void findLocalFunctions(String name, ASTNode parent) {
		List levels = TclParseUtil.findLevelsTo(this.parser.getModule(),
				parent);
		int len = levels.size();
		ASTNode realParent = findRealParent(levels);
		// At first search for namespace function
		if (realParent instanceof MethodDeclaration && !name.startsWith("::")) {
			MethodDeclaration mParent = (MethodDeclaration) realParent;
			String pName = mParent.getName();
			if (pName.indexOf("::") != -1) {
				pName = pName.substring(0, pName.lastIndexOf("::") + 2);
				processFindLocalFunctions(pName + name, levels, len);
			}
		}
		processFindLocalFunctions(name, levels, len);
	}

	protected void processFindLocalFunctions(String name, List levels,
			int len) {
		List visited = new ArrayList();
		for (int j = 0; j < len; ++j) {
			ASTNode astNodeParent = (ASTNode) levels.get(len - 1 - j);
			boolean topLevel = false;
			if (name != null && name.length() > 0 && name.charAt(0) == ':') {
				topLevel = true;
			}
			if (astNodeParent instanceof TypeDeclaration && !topLevel) {
				// Add all method here.
				TypeDeclaration decl = (TypeDeclaration) astNodeParent;
				List statements = decl.getStatements();
				if (statements != null) {
					processMethods(name, statements, "", visited);

					if (!name.startsWith("::")) {
						processMethods(decl.getName() + "::" + name, statements,
								"", visited);
					}
					if (selectionElements.size() > 0) {
						return;
					}
				}
			} else if (astNodeParent instanceof ModuleDeclaration) {
				ModuleDeclaration decl = (ModuleDeclaration) astNodeParent;
				List statements = decl.getStatements();
				processMethods(name, statements, "", visited);
				if (statements != null) {
					if (selectionElements.size() > 0) {
						return;
					}
				}
			}
		}
	}

	protected void processMethods(String name, final List statements,
			final String namePrefix, final List visited) {
		if (selectionElements.size() > 0) {
			return;
		}
		for (int i = 0; i < statements.size(); ++i) {
			ASTNode nde = (ASTNode) statements.get(i);
			if (nde instanceof MethodDeclaration) {
				String mName = ((MethodDeclaration) nde).getName();
				if (!mName.startsWith("::")) {
					mName = namePrefix + mName;
				}
				if (mName.startsWith("::::")) {
					mName = mName.substring(2);
				}
				if (name.startsWith("::")) {
					name = name.substring(2);
				}
				if (mName.startsWith("::")) {
					mName = mName.substring(2);
				}
				if (name.equals(mName)) {
					addElementFromASTNode(nde);
					if (selectionElements.size() > 0) {
						return;
					}
				}
			} else if (nde instanceof TypeDeclaration
					&& !visited.contains(nde)) {
				List tStatements = ((TypeDeclaration) nde).getStatements();
				visited.add(nde);
				String ndeName = ((TypeDeclaration) nde).getName();
				if (ndeName.startsWith("::")) {
					processMethods(name, tStatements, ndeName + "::", visited);
				} else {
					processMethods(name, tStatements,
							namePrefix + ndeName + "::", visited);
				}

			} else {
				// We need to visit blocked expressions to one level.
				final String fname = name;
				ASTVisitor visitor = new ASTVisitor() {
					@Override
					public boolean visit(Expression s) throws Exception {
						if (s instanceof Block) {
							List tStatements = ((Block) s).getStatements();
							visited.add(s);
							processMethods(fname, tStatements, namePrefix,
									visited);
						}
						return false;
					}

					@Override
					public boolean visit(MethodDeclaration s) throws Exception {
						return false;
					}

					@Override
					public boolean visit(TypeDeclaration s) throws Exception {
						return false;
					}
				};
				try {
					nde.traverse(visitor);
				} catch (Exception e) {
					if (DLTKCore.DEBUG) {
						e.printStackTrace();
					}
				}
			}

			visited.add(nde);
		}
	}

	public void addElementFromASTNode(ASTNode nde) {
		ModuleDeclaration module = parser.getModule();
		List statements = module.getStatements();
		new TclResolver(sourceModule, parser.getModule(), parentResolver)
				.searchAddElementsTo(statements, nde, sourceModule,
						this.selectionElements);
	}

	public IModelElement findElementFromNode(ASTNode nde) {
		ModuleDeclaration module = parser.getModule();
		List statements = module.getStatements();
		List<IModelElement> elements = new ArrayList<>();
		new TclResolver(sourceModule, parser.getModule(), parentResolver)
				.searchAddElementsTo(statements, nde, sourceModule, elements);
		if (elements.size() == 1) {
			return elements.get(0);
		}
		return null;
	}

	IResolveElementParent parentResolver = (node, name,
			parent) -> TclSelectionEngine.this.findElementParent(node, name,
					parent);

	protected IModelElement findElementParent(ASTNode node, String name,
			IParent parent) {
		for (int i = 0; i < extensions.length; i++) {
			IModelElement pel = extensions[i].findElementParent(node, name,
					parent, this);
			if (pel != null) {
				return pel;
			}
		}
		return null;
	}

	protected boolean checkSelection(String source, int selectionSourceStart,
			int selectionSourceEnd) {

		boolean cheat = false;
		if (selectionSourceEnd < selectionSourceStart) {
			selectionSourceEnd = selectionSourceStart;
			cheat = true;
		}

		int start = OldTclParserUtils.startLineOrNoSymbol(selectionSourceStart,
				source);
		int end = OldTclParserUtils.endLineOrNoSymbol(selectionSourceEnd,
				source);
		if (end <= start) {
			if (cheat)
				return checkSelection(source, selectionSourceEnd - 1,
						selectionSourceEnd - 1);
			return false;
		}
		if (start > source.length() || end > source.length()) {
			if (cheat)
				return checkSelection(source, selectionSourceEnd - 1,
						selectionSourceEnd - 1);
			return false;
		}

		boolean isVariable = false;
		if (source.charAt(start) == '$') {
			isVariable = true;
		} else {
			if (start > 0) { // check if it is variable
				if (source.charAt(start - 1) == '{') {
					if (start - 1 > 0 && source.charAt(start - 2) == '$') {
						start -= 2;
						isVariable = true;
						while (end < source.length()
								&& source.charAt(end) != '}')
							end++;
						if (end < source.length()) {
							end++;
						}
					}
				}
			}
		}
		if (isVariable && end < source.length() && source.charAt(end) == '(') {// it
			// is
			// array
			while (end < source.length() && source.charAt(end) != ')')
				end++;
			if (end < source.length()) {
				end++;
			}
		}
		if (isVariable && start + 1 < source.length()
				&& source.charAt(start + 1) == '{') {
			int pos = start;
			while (pos < source.length() && source.charAt(pos) != '}')
				pos++;
			if (pos < source.length()) {
				pos++;
			}
			end = pos;
		}
		if (!(start <= end && end <= source.length())) {
			System.out.println();
		}
		String sub = source.substring(start, end);
		// Lets check for variable with spaces selection
		if (!isVariable && sub.endsWith("}")) {
			int pos = end;
			while (pos > 0) {
				if (source.charAt(pos) == '{') {
					break;
				}
				pos--;
			}
			if (pos > 0) {
				if (source.charAt(pos - 1) == '$') {
					isVariable = true;
					start = pos - 1;
					sub = source.substring(start, end);
				}
			}
		}
		// If contain tabs or spaces, then from start.
		if (!isVariable && (sub.indexOf(' ') != -1 || sub.indexOf('\t') != -1
				|| sub.indexOf('\n') != -1)) {
			if (cheat)
				return checkSelection(source, selectionSourceEnd - 1,
						selectionSourceEnd - 1);
			return false;
		}
		this.actualSelectionStart = start;
		this.actualSelectionEnd = end;
		return true;
	}

	public IAssistParser getAssistParser() {
		return parser;
	}

	public IParent getSourceModule() {
		return this.sourceModule;
	}

	public IScriptProject getScriptProject() {
		return this.sourceModule.getScriptProject();
	}

	public int getActualSelectionStart() {
		return this.actualSelectionStart;
	}

	public void addSelectionElement(IModelElement element) {
		if (!selectionElements.contains(element)) {
			this.selectionElements.add(element);
		}
	}

	public int getSelectionElementsSize() {
		return this.selectionElements.size();
	}
}