core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/internal/core/hierarchy/HierarchyResolver.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 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.internal.core.hierarchy;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.DLTKLanguageManager;
 import org.eclipse.dltk.core.IDLTKLanguageToolkit;
 import org.eclipse.dltk.core.IFileHierarchyInfo;
 import org.eclipse.dltk.core.IFileHierarchyResolver;
 import org.eclipse.dltk.core.ISearchPatternProcessor;
 import org.eclipse.dltk.core.ISourceModule;
 import org.eclipse.dltk.core.IType;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.core.index2.search.ISearchEngine.MatchRule;
 import org.eclipse.dltk.core.index2.search.ModelAccess;
 import org.eclipse.dltk.core.search.IDLTKSearchConstants;
 import org.eclipse.dltk.core.search.IDLTKSearchScope;
 import org.eclipse.dltk.core.search.SearchEngine;
 import org.eclipse.dltk.core.search.SearchPattern;
 import org.eclipse.dltk.core.search.TypeNameRequestor;
 import org.eclipse.dltk.internal.core.ModelElement;
 import org.eclipse.dltk.internal.core.Openable;
 import org.eclipse.dltk.internal.core.util.HandleFactory;

 public class HierarchyResolver {

 	private HierarchyBuilder hierarchyBuilder;

 	public HierarchyResolver(HierarchyBuilder hierarchy) {
 		this.hierarchyBuilder = hierarchy;
 	}

 	public void resolve(boolean computeSubtypes) throws CoreException {

 		IType focusType = hierarchyBuilder.getType();
 		hierarchyBuilder.hierarchy.initialize(0);

 		if (computeSubtypes) {
 			computeSubtypes(focusType);
 		}
 		computeSupertypes(focusType);
 	}

 	private IType[] findTypes(String pattern, IDLTKSearchScope scope)
 			throws ModelException {

 		// First try to use new indexing infrastructure:
 		IType[] types = new ModelAccess().findTypes(pattern,
 				pattern == null ? MatchRule.PREFIX : MatchRule.EXACT, 0, 0,
 				scope, hierarchyBuilder.hierarchy.progressMonitor);
 		if (types != null) {
 			return types;
 		}

 		// Use JDT-like index:
 		final List<IType> result = new LinkedList<>();
 		final HandleFactory handleFactory = new HandleFactory();
 		TypeNameRequestor typesCollector = new TypeNameRequestor() {
 			@Override
 			public void acceptType(int modifiers, char[] packageName,
 					char[] simpleTypeName, char[][] enclosingTypeNames,
 					char[][] superTypes, String path) {

 				if (superTypes != null) {
 					for (int i = 0; i < superTypes.length; i++) {
 						Openable openable = handleFactory.createOpenable(path,
 								hierarchyBuilder.hierarchy.scope);
 						ModelElement parent = openable;
 						boolean binary = false;
 						if (openable instanceof ISourceModule) {
 							binary = ((ISourceModule) openable).isBinary();
 						}
 						if (enclosingTypeNames != null) {
 							if (!binary) {
 								for (int j = 0; j < enclosingTypeNames.length; ++j) {
 									parent = new FakeType(parent,
 											new String(enclosingTypeNames[j]));
 								}
 							} else {
 								for (int j = 0; j < enclosingTypeNames.length; ++j) {
 									if (parent instanceof ISourceModule) {
 										parent = (ModelElement) ((ISourceModule) parent)
 												.getType(new String(
 														enclosingTypeNames[j]));
 									} else if (parent instanceof IType) {
 										parent = (ModelElement) ((IType) parent)
 												.getType(new String(
 														enclosingTypeNames[j]));
 									}
 									if (parent == null) {
 										break;
 									}
 								}
 							}
 						}
 						if (parent != null) {
 							if (binary) {
 								IType type = null;
 								if (parent instanceof ISourceModule) {
 									type = ((ISourceModule) parent).getType(
 											new String(simpleTypeName));
 								} else if (parent instanceof IType) {
 									type = ((IType) parent).getType(
 											new String(simpleTypeName));
 								}
 								if (type != null) {
 									result.add(type);
 								}

 							} else {
 								FakeType type = new FakeType(parent,
 										new String(simpleTypeName), modifiers);
 								result.add(type);
 							}
 						}
 					}
 				}
 			}
 		};
 		int matchRule = SearchPattern.R_EXACT_MATCH;
 		if (pattern == null) {
 			pattern = "*"; //$NON-NLS-1$
 			matchRule = SearchPattern.R_PATTERN_MATCH;
 		}

 		SearchEngine searchEngine = new SearchEngine();
 		searchEngine.searchAllTypeNames(null, 0, pattern.toCharArray(),
 				matchRule, IDLTKSearchConstants.DECLARATIONS,
 				hierarchyBuilder.hierarchy.scope, typesCollector,
 				IDLTKSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
 				hierarchyBuilder.hierarchy.progressMonitor);

 		return result.toArray(new IType[result.size()]);
 	}

 	protected void computeSubtypes(IType focusType) throws CoreException {

 		// Collect all inheritance information:
 		final Map<String, List<String>> superTypeToExtender = new HashMap<>();
 		final String delimiter = getDelimiterReplacementString(focusType);

 		Map<String, Set<IType>> tmpCache = new HashMap<>();

 		IType[] types = findTypes(null, hierarchyBuilder.hierarchy.scope);
 		for (IType type : types) {
 			String[] superTypes = type.getSuperClasses();
 			if (superTypes != null) {
 				for (int i = 0; i < superTypes.length; i++) {
 					String s = superTypes[i];
 					List<String> extenders = superTypeToExtender.get(s);
 					if (extenders == null) {
 						extenders = new LinkedList<>();
 						superTypeToExtender.put(s, extenders);
 					}
 					extenders.add(type.getTypeQualifiedName(delimiter));
 				}
 			}

 			// Cache this type for further searches
 			String elementName = type.getElementName();
 			Set<IType> set = tmpCache.get(elementName);
 			if (set == null) {
 				set = new HashSet<>();
 				tmpCache.put(elementName, set);
 			}
 			set.add(type);
 		}

 		// Rebuild temporary cache in a useful format:
 		HashMap<String, IType[]> cache = new HashMap<>();
 		Iterator<String> i = tmpCache.keySet().iterator();
 		while (i.hasNext()) {
 			String typeName = i.next();
 			Set<IType> typeElements = tmpCache.get(typeName);
 			cache.put(typeName,
 					typeElements.toArray(new IType[typeElements.size()]));
 		}

 		// Create file hierarchy resolver for filtering non-included elements
 		IFileHierarchyResolver fileHierarchyResolver = createFileHierarchyResolver(
 				focusType);
 		IFileHierarchyInfo hierarchyInfo = null;
 		if (fileHierarchyResolver != null) {
 			hierarchyInfo = fileHierarchyResolver.resolveDown(
 					focusType.getSourceModule(),
 					hierarchyBuilder.hierarchy.progressMonitor);
 		}

 		computeSubtypesFor(focusType, superTypeToExtender, cache, hierarchyInfo,
 				new HashSet<IType>(), delimiter);
 	}

 	protected void computeSubtypesFor(IType focusType,
 			Map<String, List<String>> superTypeToExtender,
 			Map<String, IType[]> subTypesCache,
 			IFileHierarchyInfo hierarchyInfo, Set<IType> processedTypes,
 			String delimiter) throws CoreException {

 		List<String> extenders = superTypeToExtender
 				.get(focusType.getTypeQualifiedName(delimiter));
 		if (extenders != null) {
 			IType[] subTypes = searchTypes(
 					extenders.toArray(new String[extenders.size()]),
 					subTypesCache, hierarchyInfo);
 			for (int i = 0; i < subTypes.length; i++) {
 				IType subType = subTypes[i];
 				hierarchyBuilder.hierarchy.addSubtype(focusType, subType);
 			}

 			for (int i = 0; i < subTypes.length; i++) {
 				IType subType = subTypes[i];
 				if (processedTypes.add(subType)) {
 					computeSubtypesFor(subType, superTypeToExtender,
 							subTypesCache, hierarchyInfo, processedTypes,
 							delimiter);
 				}
 			}
 		}
 	}

 	protected void computeSupertypes(IType focusType) throws CoreException {
 		IFileHierarchyResolver fileHierarchyResolver = createFileHierarchyResolver(
 				focusType);
 		IFileHierarchyInfo hierarchyInfo = null;
 		if (fileHierarchyResolver != null) {
 			hierarchyInfo = fileHierarchyResolver.resolveUp(
 					focusType.getSourceModule(),
 					hierarchyBuilder.hierarchy.progressMonitor);
 		}

 		computeSupertypesFor(focusType, new HashMap<String, IType[]>(),
 				hierarchyInfo, new HashSet<IType>());
 	}

 	protected void computeSupertypesFor(IType focusType,
 			Map<String, IType[]> superTypesCache,
 			IFileHierarchyInfo hierarchyInfo, Set<IType> processedTypes)
 			throws CoreException {

 		processedTypes.add(focusType);

 		// Build superclasses hieararchy:
 		String[] superClasses = focusType.getSuperClasses();
 		if (superClasses != null && superClasses.length > 0) {
 			IType[] searchTypes = searchTypes(superClasses, superTypesCache,
 					hierarchyInfo);

 			for (int i = 0; i < searchTypes.length; i++) {
 				IType superclass = searchTypes[i];
 				hierarchyBuilder.hierarchy.cacheSuperclass(focusType,
 						superclass);
 			}

 			for (int i = 0; i < searchTypes.length; i++) {
 				IType superclass = searchTypes[i];
 				if (!processedTypes.contains(superclass)) {
 					computeSupertypesFor(superclass, superTypesCache,
 							hierarchyInfo, processedTypes);
 				}
 			}
 		} else {
 			if (!hierarchyBuilder.hierarchy.contains(focusType)) {
 				hierarchyBuilder.hierarchy.addRootClass(focusType);
 			}
 		}
 	}

 	protected IType[] searchTypes(String[] typeNames,
 			Map<String, IType[]> cache, IFileHierarchyInfo hierarchyInfo)
 			throws CoreException {
 		List<IType> result = new LinkedList<>();
 		for (int i = 0; i < typeNames.length; i++) {
 			String typeName = typeNames[i];
 			result.addAll(
 					Arrays.asList(searchTypes(typeName, cache, hierarchyInfo)));
 		}
 		return result.toArray(new IType[result.size()]);
 	}

 	protected IType[] searchTypes(String type, IFileHierarchyInfo hierarchyInfo)
 			throws CoreException {
 		return searchTypes(type, null, hierarchyInfo);
 	}

 	protected IType[] searchTypes(final String typeName,
 			Map<String, IType[]> cache, final IFileHierarchyInfo hierarchyInfo)
 			throws CoreException {
 		if (cache != null && cache.containsKey(typeName)) {
 			return cache.get(typeName);
 		}

 		final List<IType> result = new LinkedList<>();
 		final List<IType> filteredTypes = new LinkedList<>();

 		IType[] types = findTypes(typeName, hierarchyBuilder.hierarchy.scope);
 		for (IType type : types) {
 			String delimiter = getDelimiterReplacementString(type);
 			String qualifiedName = type.getTypeQualifiedName(delimiter);
 			if (!typeName.equalsIgnoreCase(qualifiedName)) {
 				continue;
 			}

 			if (hierarchyInfo != null
 					&& !hierarchyInfo.exists(type.getSourceModule())) {
 				filteredTypes.add(type);
 			} else {
 				result.add(type);
 			}
 		}

 		// If all results where filtered that means we could find a path to any
 		// of elements.
 		// In this case return all elements.
 		if (result.isEmpty()) {
 			result.addAll(filteredTypes);
 		}

 		types = result.toArray(new IType[result.size()]);
 		if (cache != null) {
 			cache.put(typeName, types);
 		}
 		return types;
 	}

 	public void resolve(Openable[] openables, HashSet<String> localTypes) {
 		try {
 			resolve(true);
 		} catch (CoreException e) {
 			if (DLTKCore.DEBUG) {
 				e.printStackTrace();
 			}
 		}
 	}

 	private static IFileHierarchyResolver createFileHierarchyResolver(
 			IType type) throws CoreException {
 		IFileHierarchyResolver fileHierarchyResolver = null;
 		IDLTKLanguageToolkit toolkit = DLTKLanguageManager
 				.getLanguageToolkit(type);
 		if (toolkit != null) {
 			fileHierarchyResolver = DLTKLanguageManager
 					.getFileHierarchyResolver(toolkit.getNatureId());
 		}
 		return fileHierarchyResolver;
 	}

 	private static ISearchPatternProcessor getSearchPatternProcessor(
 			IType type) {
 		return DLTKLanguageManager.getSearchPatternProcessor(
 				DLTKLanguageManager.getLanguageToolkit(type));
 	}

 	protected String getDelimiterReplacementString(IType type) {
 		ISearchPatternProcessor searchPatternProcessor = getSearchPatternProcessor(
 				type);
 		if (searchPatternProcessor != null) {
 			return searchPatternProcessor.getDelimiterReplacementString();
 		}
 		return "::"; // $NON-NLS-N$
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 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.internal.core.hierarchy;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.DLTKLanguageManager;
	import org.eclipse.dltk.core.IDLTKLanguageToolkit;
	import org.eclipse.dltk.core.IFileHierarchyInfo;
	import org.eclipse.dltk.core.IFileHierarchyResolver;
	import org.eclipse.dltk.core.ISearchPatternProcessor;
	import org.eclipse.dltk.core.ISourceModule;
	import org.eclipse.dltk.core.IType;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.core.index2.search.ISearchEngine.MatchRule;
	import org.eclipse.dltk.core.index2.search.ModelAccess;
	import org.eclipse.dltk.core.search.IDLTKSearchConstants;
	import org.eclipse.dltk.core.search.IDLTKSearchScope;
	import org.eclipse.dltk.core.search.SearchEngine;
	import org.eclipse.dltk.core.search.SearchPattern;
	import org.eclipse.dltk.core.search.TypeNameRequestor;
	import org.eclipse.dltk.internal.core.ModelElement;
	import org.eclipse.dltk.internal.core.Openable;
	import org.eclipse.dltk.internal.core.util.HandleFactory;

	public class HierarchyResolver {

	private HierarchyBuilder hierarchyBuilder;

	public HierarchyResolver(HierarchyBuilder hierarchy) {
	this.hierarchyBuilder = hierarchy;
	}

	public void resolve(boolean computeSubtypes) throws CoreException {

	IType focusType = hierarchyBuilder.getType();
	hierarchyBuilder.hierarchy.initialize(0);

	if (computeSubtypes) {
	computeSubtypes(focusType);
	}
	computeSupertypes(focusType);
	}

	private IType[] findTypes(String pattern, IDLTKSearchScope scope)
	throws ModelException {

	// First try to use new indexing infrastructure:
	IType[] types = new ModelAccess().findTypes(pattern,
	pattern == null ? MatchRule.PREFIX : MatchRule.EXACT, 0, 0,
	scope, hierarchyBuilder.hierarchy.progressMonitor);
	if (types != null) {
	return types;
	}

	// Use JDT-like index:
	final List<IType> result = new LinkedList<>();
	final HandleFactory handleFactory = new HandleFactory();
	TypeNameRequestor typesCollector = new TypeNameRequestor() {
	@Override
	public void acceptType(int modifiers, char[] packageName,
	char[] simpleTypeName, char[][] enclosingTypeNames,
	char[][] superTypes, String path) {

	if (superTypes != null) {
	for (int i = 0; i < superTypes.length; i++) {
	Openable openable = handleFactory.createOpenable(path,
	hierarchyBuilder.hierarchy.scope);
	ModelElement parent = openable;
	boolean binary = false;
	if (openable instanceof ISourceModule) {
	binary = ((ISourceModule) openable).isBinary();
	}
	if (enclosingTypeNames != null) {
	if (!binary) {
	for (int j = 0; j < enclosingTypeNames.length; ++j) {
	parent = new FakeType(parent,
	new String(enclosingTypeNames[j]));
	}
	} else {
	for (int j = 0; j < enclosingTypeNames.length; ++j) {
	if (parent instanceof ISourceModule) {
	parent = (ModelElement) ((ISourceModule) parent)
	.getType(new String(
	enclosingTypeNames[j]));
	} else if (parent instanceof IType) {
	parent = (ModelElement) ((IType) parent)
	.getType(new String(
	enclosingTypeNames[j]));
	}
	if (parent == null) {
	break;
	}
	}
	}
	}
	if (parent != null) {
	if (binary) {
	IType type = null;
	if (parent instanceof ISourceModule) {
	type = ((ISourceModule) parent).getType(
	new String(simpleTypeName));
	} else if (parent instanceof IType) {
	type = ((IType) parent).getType(
	new String(simpleTypeName));
	}
	if (type != null) {
	result.add(type);
	}

	} else {
	FakeType type = new FakeType(parent,
	new String(simpleTypeName), modifiers);
	result.add(type);
	}
	}
	}
	}
	}
	};
	int matchRule = SearchPattern.R_EXACT_MATCH;
	if (pattern == null) {
	pattern = "*"; //$NON-NLS-1$
	matchRule = SearchPattern.R_PATTERN_MATCH;
	}

	SearchEngine searchEngine = new SearchEngine();
	searchEngine.searchAllTypeNames(null, 0, pattern.toCharArray(),
	matchRule, IDLTKSearchConstants.DECLARATIONS,
	hierarchyBuilder.hierarchy.scope, typesCollector,
	IDLTKSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
	hierarchyBuilder.hierarchy.progressMonitor);

	return result.toArray(new IType[result.size()]);
	}

	protected void computeSubtypes(IType focusType) throws CoreException {

	// Collect all inheritance information:
	final Map<String, List<String>> superTypeToExtender = new HashMap<>();
	final String delimiter = getDelimiterReplacementString(focusType);

	Map<String, Set<IType>> tmpCache = new HashMap<>();

	IType[] types = findTypes(null, hierarchyBuilder.hierarchy.scope);
	for (IType type : types) {
	String[] superTypes = type.getSuperClasses();
	if (superTypes != null) {
	for (int i = 0; i < superTypes.length; i++) {
	String s = superTypes[i];
	List<String> extenders = superTypeToExtender.get(s);
	if (extenders == null) {
	extenders = new LinkedList<>();
	superTypeToExtender.put(s, extenders);
	}
	extenders.add(type.getTypeQualifiedName(delimiter));
	}
	}

	// Cache this type for further searches
	String elementName = type.getElementName();
	Set<IType> set = tmpCache.get(elementName);
	if (set == null) {
	set = new HashSet<>();
	tmpCache.put(elementName, set);
	}
	set.add(type);
	}

	// Rebuild temporary cache in a useful format:
	HashMap<String, IType[]> cache = new HashMap<>();
	Iterator<String> i = tmpCache.keySet().iterator();
	while (i.hasNext()) {
	String typeName = i.next();
	Set<IType> typeElements = tmpCache.get(typeName);
	cache.put(typeName,
	typeElements.toArray(new IType[typeElements.size()]));
	}

	// Create file hierarchy resolver for filtering non-included elements
	IFileHierarchyResolver fileHierarchyResolver = createFileHierarchyResolver(
	focusType);
	IFileHierarchyInfo hierarchyInfo = null;
	if (fileHierarchyResolver != null) {
	hierarchyInfo = fileHierarchyResolver.resolveDown(
	focusType.getSourceModule(),
	hierarchyBuilder.hierarchy.progressMonitor);
	}

	computeSubtypesFor(focusType, superTypeToExtender, cache, hierarchyInfo,
	new HashSet<IType>(), delimiter);
	}

	protected void computeSubtypesFor(IType focusType,
	Map<String, List<String>> superTypeToExtender,
	Map<String, IType[]> subTypesCache,
	IFileHierarchyInfo hierarchyInfo, Set<IType> processedTypes,
	String delimiter) throws CoreException {

	List<String> extenders = superTypeToExtender
	.get(focusType.getTypeQualifiedName(delimiter));
	if (extenders != null) {
	IType[] subTypes = searchTypes(
	extenders.toArray(new String[extenders.size()]),
	subTypesCache, hierarchyInfo);
	for (int i = 0; i < subTypes.length; i++) {
	IType subType = subTypes[i];
	hierarchyBuilder.hierarchy.addSubtype(focusType, subType);
	}

	for (int i = 0; i < subTypes.length; i++) {
	IType subType = subTypes[i];
	if (processedTypes.add(subType)) {
	computeSubtypesFor(subType, superTypeToExtender,
	subTypesCache, hierarchyInfo, processedTypes,
	delimiter);
	}
	}
	}
	}

	protected void computeSupertypes(IType focusType) throws CoreException {
	IFileHierarchyResolver fileHierarchyResolver = createFileHierarchyResolver(
	focusType);
	IFileHierarchyInfo hierarchyInfo = null;
	if (fileHierarchyResolver != null) {
	hierarchyInfo = fileHierarchyResolver.resolveUp(
	focusType.getSourceModule(),
	hierarchyBuilder.hierarchy.progressMonitor);
	}

	computeSupertypesFor(focusType, new HashMap<String, IType[]>(),
	hierarchyInfo, new HashSet<IType>());
	}

	protected void computeSupertypesFor(IType focusType,
	Map<String, IType[]> superTypesCache,
	IFileHierarchyInfo hierarchyInfo, Set<IType> processedTypes)
	throws CoreException {

	processedTypes.add(focusType);

	// Build superclasses hieararchy:
	String[] superClasses = focusType.getSuperClasses();
	if (superClasses != null && superClasses.length > 0) {
	IType[] searchTypes = searchTypes(superClasses, superTypesCache,
	hierarchyInfo);

	for (int i = 0; i < searchTypes.length; i++) {
	IType superclass = searchTypes[i];
	hierarchyBuilder.hierarchy.cacheSuperclass(focusType,
	superclass);
	}

	for (int i = 0; i < searchTypes.length; i++) {
	IType superclass = searchTypes[i];
	if (!processedTypes.contains(superclass)) {
	computeSupertypesFor(superclass, superTypesCache,
	hierarchyInfo, processedTypes);
	}
	}
	} else {
	if (!hierarchyBuilder.hierarchy.contains(focusType)) {
	hierarchyBuilder.hierarchy.addRootClass(focusType);
	}
	}
	}

	protected IType[] searchTypes(String[] typeNames,
	Map<String, IType[]> cache, IFileHierarchyInfo hierarchyInfo)
	throws CoreException {
	List<IType> result = new LinkedList<>();
	for (int i = 0; i < typeNames.length; i++) {
	String typeName = typeNames[i];
	result.addAll(
	Arrays.asList(searchTypes(typeName, cache, hierarchyInfo)));
	}
	return result.toArray(new IType[result.size()]);
	}

	protected IType[] searchTypes(String type, IFileHierarchyInfo hierarchyInfo)
	throws CoreException {
	return searchTypes(type, null, hierarchyInfo);
	}

	protected IType[] searchTypes(final String typeName,
	Map<String, IType[]> cache, final IFileHierarchyInfo hierarchyInfo)
	throws CoreException {
	if (cache != null && cache.containsKey(typeName)) {
	return cache.get(typeName);
	}

	final List<IType> result = new LinkedList<>();
	final List<IType> filteredTypes = new LinkedList<>();

	IType[] types = findTypes(typeName, hierarchyBuilder.hierarchy.scope);
	for (IType type : types) {
	String delimiter = getDelimiterReplacementString(type);
	String qualifiedName = type.getTypeQualifiedName(delimiter);
	if (!typeName.equalsIgnoreCase(qualifiedName)) {
	continue;
	}

	if (hierarchyInfo != null
	&& !hierarchyInfo.exists(type.getSourceModule())) {
	filteredTypes.add(type);
	} else {
	result.add(type);
	}
	}

	// If all results where filtered that means we could find a path to any
	// of elements.
	// In this case return all elements.
	if (result.isEmpty()) {
	result.addAll(filteredTypes);
	}

	types = result.toArray(new IType[result.size()]);
	if (cache != null) {
	cache.put(typeName, types);
	}
	return types;
	}

	public void resolve(Openable[] openables, HashSet<String> localTypes) {
	try {
	resolve(true);
	} catch (CoreException e) {
	if (DLTKCore.DEBUG) {
	e.printStackTrace();
	}
	}
	}

	private static IFileHierarchyResolver createFileHierarchyResolver(
	IType type) throws CoreException {
	IFileHierarchyResolver fileHierarchyResolver = null;
	IDLTKLanguageToolkit toolkit = DLTKLanguageManager
	.getLanguageToolkit(type);
	if (toolkit != null) {
	fileHierarchyResolver = DLTKLanguageManager
	.getFileHierarchyResolver(toolkit.getNatureId());
	}
	return fileHierarchyResolver;
	}

	private static ISearchPatternProcessor getSearchPatternProcessor(
	IType type) {
	return DLTKLanguageManager.getSearchPatternProcessor(
	DLTKLanguageManager.getLanguageToolkit(type));
	}

	protected String getDelimiterReplacementString(IType type) {
	ISearchPatternProcessor searchPatternProcessor = getSearchPatternProcessor(
	type);
	if (searchPatternProcessor != null) {
	return searchPatternProcessor.getDelimiterReplacementString();
	}
	return "::"; // $NON-NLS-N$
	}
	}