jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/Util.java

/*******************************************************************************
 * Copyright (c) 2007 Oracle Corporation.
 * 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:
 *    Cameron Bateman/Oracle - initial API and implementation
 *    
 ********************************************************************************/
package org.eclipse.jst.jsf.context.symbol.internal.impl;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.emf.common.util.EList;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jst.jsf.common.JSFCommonPlugin;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.internal.types.ValueType;
import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
import org.eclipse.jst.jsf.common.util.TypeUtil;
import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
import org.eclipse.jst.jsf.context.symbol.IPropertySymbol;
import org.eclipse.jst.jsf.context.symbol.ISymbol;
import org.eclipse.jst.jsf.context.symbol.ITypeDescriptor;
import org.eclipse.jst.jsf.context.symbol.SymbolFactory;

final class Util 
{
    static ISymbol call(String methodName, EList methodArguments,
            String symbolName, ITypeDescriptor typeDesc)
    {
        // first, see if the type descriptor wants to handle the call
        ISymbol result = typeDesc.calculateSyntheticCall(methodName, methodArguments, symbolName);

        final IType type= typeDesc.resolveType(typeDesc.getTypeSignature());
        
        // if the type is resolved and the typeDesc didn't already handle
        // the call then do this the hard way...
        if (type != null && result == null)
        {
            final JDTBeanIntrospector introspector = 
                new JDTBeanIntrospector(type);

            final IMethod callMethod = 
                Util.matchMethod(methodName, methodArguments, introspector.getAllMethods(),typeDesc.getTypeParameterSignatures());

            if (callMethod != null)
            {
                try 
                {
                    // resolve the method's return type; don't erase parameters
                    String retTypeSignature = callMethod.getReturnType();
                        
                    // if we have a type variable, try to parameter match it
                    if (Signature.getTypeSignatureKind(retTypeSignature) == Signature.TYPE_VARIABLE_SIGNATURE)
                    {
                        retTypeSignature = TypeUtil.matchTypeParameterToArgument
                            (type
                               , retTypeSignature, typeDesc.getTypeParameterSignatures());
                        
                        if (retTypeSignature == null)
                        {
                            retTypeSignature = TypeConstants.TYPE_JAVAOBJECT;
                        }
                    }
                    // otherwise, try and resolve it in type
                    else
                    {
                    	retTypeSignature = TypeUtil.resolveTypeSignature
                    		(type, callMethod.getReturnType(), false);
                    }

                    final IPropertySymbol  propSymbol = 
                        SymbolFactory.eINSTANCE.createIPropertySymbol();

                    // TODO: there is a possible problem here for non-string keyed maps
                    propSymbol.setName(symbolName);
                    propSymbol.setReadable(true);
                    
                    {
                        IJavaTypeDescriptor2 newTypeDesc = null;
                        
                        if (retTypeSignature.equals(TypeConstants.TYPE_JAVAOBJECT))
                        {
                            newTypeDesc = SymbolFactory.eINSTANCE.createIBoundedJavaTypeDescriptor();
                        }
                        else
                        {
                            newTypeDesc = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
                        }
                        
                        newTypeDesc.setArrayCount(Signature.getArrayCount(retTypeSignature));
                        
                        // may be null
                        newTypeDesc.setType(typeDesc.resolveType(retTypeSignature));
                        newTypeDesc.setTypeSignatureDelegate(retTypeSignature);
                        propSymbol.setTypeDescriptor(newTypeDesc);
                    }
                    
                    result = propSymbol;
                } 
                catch (JavaModelException e) 
                {
                    JSFCommonPlugin.log(e);
                    // fall-through and return null result
                }
            }
        }

        return result;
    }

    static IMethod matchMethod(String methodName, List methodArguments, IMethod[] allMethods, List typeParameterSignatures)
    {
//        final List argSigs = convertArgsToSignatures(methodArguments);
        IMethod matchedMethod = null;

        for (int i = 0; i < allMethods.length; i++)
        {
            final IMethod method = allMethods[i];
            
            // check for names and argument count match
            if (method.getParameterTypes().length == methodArguments.size()
                    && method.getElementName().equals(methodName))
            {
                List<String> methods = resolveMethodParameters(method, typeParameterSignatures);
                
                // need to verify argument matches
                boolean isMatched = true;
                CHECK_ARGUMENTS: for (int j = 0; j < methods.size(); j++)
                {
                    final ValueType valueType = (ValueType) methodArguments.get(j);

                    // if the parameters match, or if the method expects an object
                    // and we have a class
                    // TODO: there are some cases not supported here like:
                    // - method name overloading
                    // - autoboxing primitives
                    // - certain kinds of parameterized args
                    if (!methods.get(j).equals(valueType.getSignature())
                         && !(methods.get(j).equals(TypeConstants.TYPE_JAVAOBJECT)
                                 && Signature.getTypeSignatureKind(valueType.getSignature())==Signature.CLASS_TYPE_SIGNATURE))
                    {
                        // not a match
                        isMatched = false;
                        break CHECK_ARGUMENTS;
                    }
                }
                
                if (isMatched)
                {
                    return method;
                }
            }
        }

        return matchedMethod;
    }
    
    static List<String> resolveMethodParameters(IMethod method, List typeParametersSignatures)
    {
        List<String>   resolved = new ArrayList<String>();
        String[] parameterTypes = method.getParameterTypes();
        for (String parameter : parameterTypes)
        { 
            parameter = TypeUtil.resolveTypeSignature(method.getDeclaringType()
                    , parameter, false);
            
            if (Signature.getTypeSignatureKind(parameter) == Signature.TYPE_VARIABLE_SIGNATURE)
            {
                parameter = TypeUtil.matchTypeParameterToArgument
                    (method.getDeclaringType(), parameter, typeParametersSignatures);
            }
            
            if (parameter == null)
            {
                parameter = TypeConstants.TYPE_JAVAOBJECT;
            }
            
            resolved.add(parameter);
        }
        
        return resolved;
    }
}