TypeReferencePredicate.java

/*******************************************************************************
 * Copyright (c) 2010 xored software, Inc.
 *
 * 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:
 *     xored software, Inc. - initial API and Implementation (Alex Panchenko)
 *******************************************************************************/
package org.eclipse.dltk.javascript.internal.search;

import java.util.Collection;

import org.eclipse.dltk.compiler.CharOperation;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.ISearchPatternProcessor;
import org.eclipse.dltk.core.search.matching2.AbstractMatchingPredicate;
import org.eclipse.dltk.core.search.matching2.MatchLevel;
import org.eclipse.dltk.internal.core.search.matching.TypeReferencePattern;
import org.eclipse.dltk.internal.javascript.parser.structure.StructureRequestor;
import org.eclipse.dltk.javascript.core.JavaScriptNature;
import org.eclipse.dltk.javascript.typeinfo.IModelBuilder.IParameter;
import org.eclipse.dltk.javascript.typeinfo.ITypeSystem;
import org.eclipse.dltk.javascript.typeinfo.model.JSType;

@SuppressWarnings("restriction")
public class TypeReferencePredicate extends
		AbstractMatchingPredicate<MatchingNode> {

	final ITypeSystem context;

	/**
	 * @param pattern
	 * @param namePattern
	 */
	public TypeReferencePredicate(ITypeSystem context,
			TypeReferencePattern pattern) {
		super(pattern, concat(pattern.qualification, pattern.simpleName));
		this.context = context;
	}

	private static char[] concat(char[] qualification, char[] simpleName) {
		if (qualification != null) {
			final ISearchPatternProcessor patternProcessor = DLTKLanguageManager
					.getSearchPatternProcessor(JavaScriptNature.NATURE_ID);
			final char[] separator = (patternProcessor != null ? patternProcessor
					.getDelimiterReplacementString() : "/").toCharArray();
			return CharOperation.concat(CharOperation.replace(qualification,
					new char[] { '$' }, separator), separator, simpleName);
		}
		return simpleName;
	}

	public MatchLevel match(MatchingNode node) {
		if (node instanceof MethodDeclarationNode) {
			MethodDeclarationNode mNode = (MethodDeclarationNode) node;
			MatchLevel level = matchTypeName(mNode.method.getType());
			if (level != null) {
				return level;
			}
			for (IParameter parameter : mNode.method.getParameters()) {
				level = matchTypeName(parameter.getType());
				if (level != null) {
					return level;
				}
			}
		} else if (node instanceof FieldDeclarationNode) {
			FieldDeclarationNode fNode = (FieldDeclarationNode) node;
			return matchTypeName(fNode.declaredType);
		} else if (node instanceof LocalVariableDeclarationNode
				&& !(node instanceof ArgumentDeclarationNode)) {
			LocalVariableDeclarationNode vNode = (LocalVariableDeclarationNode) node;
			return matchTypeName(vNode.declaredType);
		} else if (node instanceof TypeReferenceNode) {
			final TypeReferenceNode ref = (TypeReferenceNode) node;
			return matchTypeNames(ref.typeNames);
		}
		return null;
	}

	private MatchLevel matchTypeNames(final Collection<String> typeNames) {
		MatchLevel result = null;
		for (String typeName : typeNames) {
			final MatchLevel level = matchName(typeName,
					MatchLevel.ACCURATE_MATCH);
			if (level != null
					&& (result == null || level.compareTo(result) > 0)) {
				result = level;
			}
		}
		return result;
	}

	private MatchLevel matchTypeName(JSType type) {
		if (type == null)
			return null;
		return matchTypeNames(StructureRequestor
				.collectContainedTypeNames(type));
	}
}