1/*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26/*
27 * This file is available under and governed by the GNU General Public
28 * License version 2 only, as published by the Free Software Foundation.
29 * However, the following notice accompanied the original version of this
30 * file, and Oracle licenses the original version of this file under the BSD
31 * license:
32 */
33/*
34   Copyright 2009-2013 Attila Szegedi
35
36   Licensed under both the Apache License, Version 2.0 (the "Apache License")
37   and the BSD License (the "BSD License"), with licensee being free to
38   choose either of the two at their discretion.
39
40   You may not use this file except in compliance with either the Apache
41   License or the BSD License.
42
43   If you choose to use this file in compliance with the Apache License, the
44   following notice applies to you:
45
46       You may obtain a copy of the Apache License at
47
48           http://www.apache.org/licenses/LICENSE-2.0
49
50       Unless required by applicable law or agreed to in writing, software
51       distributed under the License is distributed on an "AS IS" BASIS,
52       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
53       implied. See the License for the specific language governing
54       permissions and limitations under the License.
55
56   If you choose to use this file in compliance with the BSD License, the
57   following notice applies to you:
58
59       Redistribution and use in source and binary forms, with or without
60       modification, are permitted provided that the following conditions are
61       met:
62       * Redistributions of source code must retain the above copyright
63         notice, this list of conditions and the following disclaimer.
64       * Redistributions in binary form must reproduce the above copyright
65         notice, this list of conditions and the following disclaimer in the
66         documentation and/or other materials provided with the distribution.
67       * Neither the name of the copyright holder nor the names of
68         contributors may be used to endorse or promote products derived from
69         this software without specific prior written permission.
70
71       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
72       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
73       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
74       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
75       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
76       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
77       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
78       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
79       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
80       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
81       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
82*/
83
84package jdk.dynalink.beans;
85
86import java.lang.invoke.MethodHandle;
87import java.lang.invoke.MethodHandles;
88import java.lang.invoke.MethodType;
89import java.util.ArrayList;
90import java.util.Iterator;
91import java.util.List;
92import java.util.Map;
93import java.util.concurrent.ConcurrentHashMap;
94import jdk.dynalink.SecureLookupSupplier;
95import jdk.dynalink.internal.InternalTypeUtilities;
96import jdk.dynalink.linker.LinkerServices;
97import jdk.dynalink.linker.support.Lookup;
98
99/**
100 * Represents a subset of overloaded methods for a certain method name on a certain class. It can be either a fixarg or
101 * a vararg subset depending on the subclass. The method is for a fixed number of arguments though (as it is generated
102 * for a concrete call site). As such, all methods in the subset can be invoked with the specified number of arguments
103 * (exactly matching for fixargs, or having less than or equal fixed arguments, for varargs).
104 */
105class OverloadedMethod {
106    private final Map<ClassString, MethodHandle> argTypesToMethods = new ConcurrentHashMap<>();
107    private final OverloadedDynamicMethod parent;
108    private final ClassLoader callSiteClassLoader;
109    private final MethodType callSiteType;
110    private final MethodHandle invoker;
111    private final LinkerServices linkerServices;
112    private final SecureLookupSupplier lookupSupplier;
113    private final ArrayList<MethodHandle> fixArgMethods;
114    private final ArrayList<MethodHandle> varArgMethods;
115
116    OverloadedMethod(final List<MethodHandle> methodHandles,
117            final OverloadedDynamicMethod parent,
118            final ClassLoader callSiteClassLoader,
119            final MethodType callSiteType,
120            final LinkerServices linkerServices,
121            final SecureLookupSupplier lookupSupplier) {
122        this.parent = parent;
123        this.callSiteClassLoader = callSiteClassLoader;
124        final Class<?> commonRetType = getCommonReturnType(methodHandles);
125        this.callSiteType = callSiteType.changeReturnType(commonRetType);
126        this.linkerServices = linkerServices;
127        this.lookupSupplier = lookupSupplier;
128
129        fixArgMethods = new ArrayList<>(methodHandles.size());
130        varArgMethods = new ArrayList<>(methodHandles.size());
131        final int argNum = callSiteType.parameterCount();
132        for(final MethodHandle mh: methodHandles) {
133            if(mh.isVarargsCollector()) {
134                final MethodHandle asFixed = mh.asFixedArity();
135                if(argNum == asFixed.type().parameterCount()) {
136                    fixArgMethods.add(asFixed);
137                }
138                varArgMethods.add(mh);
139            } else {
140                fixArgMethods.add(mh);
141            }
142        }
143        fixArgMethods.trimToSize();
144        varArgMethods.trimToSize();
145
146        final MethodHandle bound = SELECT_METHOD.bindTo(this);
147        final MethodHandle collecting = SingleDynamicMethod.collectArguments(bound, argNum).asType(
148                callSiteType.changeReturnType(MethodHandle.class));
149        invoker = linkerServices.asTypeLosslessReturn(MethodHandles.foldArguments(
150                MethodHandles.exactInvoker(this.callSiteType), collecting), callSiteType);
151    }
152
153    MethodHandle getInvoker() {
154        return invoker;
155    }
156
157    private static final MethodHandle SELECT_METHOD = Lookup.findOwnSpecial(MethodHandles.lookup(), "selectMethod",
158            MethodHandle.class, Object[].class);
159
160    @SuppressWarnings("unused")
161    private MethodHandle selectMethod(final Object[] args) throws NoSuchMethodException {
162        final Class<?>[] argTypes = new Class<?>[args.length];
163        for(int i = 0; i < argTypes.length; ++i) {
164            final Object arg = args[i];
165            argTypes[i] = arg == null ? ClassString.NULL_CLASS : arg.getClass();
166        }
167        final ClassString classString = new ClassString(argTypes);
168        MethodHandle method = argTypesToMethods.get(classString);
169        if(method == null) {
170            List<MethodHandle> methods = classString.getMaximallySpecifics(fixArgMethods, linkerServices, false);
171            if(methods.isEmpty()) {
172                methods = classString.getMaximallySpecifics(varArgMethods, linkerServices, true);
173            }
174            switch(methods.size()) {
175                case 0: {
176                    method = getNoSuchMethodThrower(argTypes);
177                    break;
178                }
179                case 1: {
180                    final List<MethodHandle> fmethods = methods;
181                    method = linkerServices.getWithLookup(
182                            ()->SingleDynamicMethod.getInvocation(fmethods.get(0), callSiteType, linkerServices),
183                            lookupSupplier);
184                    break;
185                }
186                default: {
187                    // This is unfortunate - invocation time ambiguity.
188                    method = getAmbiguousMethodThrower(argTypes, methods);
189                    break;
190                }
191            }
192            // Avoid keeping references to unrelated classes; this ruins the
193            // performance a bit, but avoids class loader memory leaks.
194            if(classString.isVisibleFrom(callSiteClassLoader)) {
195                argTypesToMethods.put(classString, method);
196            }
197        }
198        return method;
199    }
200
201    private MethodHandle getNoSuchMethodThrower(final Class<?>[] argTypes) {
202        return adaptThrower(MethodHandles.insertArguments(THROW_NO_SUCH_METHOD, 0, this, argTypes));
203    }
204
205    private static final MethodHandle THROW_NO_SUCH_METHOD = Lookup.findOwnSpecial(MethodHandles.lookup(),
206            "throwNoSuchMethod", void.class, Class[].class);
207
208    @SuppressWarnings("unused")
209    private void throwNoSuchMethod(final Class<?>[] argTypes) throws NoSuchMethodException {
210        if(varArgMethods.isEmpty()) {
211            throw new NoSuchMethodException("None of the fixed arity signatures " + getSignatureList(fixArgMethods) +
212                    " of method " + parent.getName() + " match the argument types " + argTypesString(argTypes));
213        }
214        throw new NoSuchMethodException("None of the fixed arity signatures " + getSignatureList(fixArgMethods) +
215                " or the variable arity signatures " + getSignatureList(varArgMethods) + " of the method " +
216                parent.getName() + " match the argument types " + argTypesString(argTypes));
217    }
218
219    private MethodHandle getAmbiguousMethodThrower(final Class<?>[] argTypes, final List<MethodHandle> methods) {
220        return adaptThrower(MethodHandles.insertArguments(THROW_AMBIGUOUS_METHOD, 0, this, argTypes, methods));
221    }
222
223    private MethodHandle adaptThrower(final MethodHandle rawThrower) {
224        return MethodHandles.dropArguments(rawThrower, 0, callSiteType.parameterList()).asType(callSiteType);
225    }
226
227    private static final MethodHandle THROW_AMBIGUOUS_METHOD = Lookup.findOwnSpecial(MethodHandles.lookup(),
228            "throwAmbiguousMethod", void.class, Class[].class, List.class);
229
230    @SuppressWarnings("unused")
231    private void throwAmbiguousMethod(final Class<?>[] argTypes, final List<MethodHandle> methods) throws NoSuchMethodException {
232        final String arity = methods.get(0).isVarargsCollector() ? "variable" : "fixed";
233        throw new NoSuchMethodException("Can't unambiguously select between " + arity + " arity signatures " +
234                getSignatureList(methods) + " of the method " + parent.getName() + " for argument types " +
235                argTypesString(argTypes));
236    }
237
238    private static String argTypesString(final Class<?>[] classes) {
239        final StringBuilder b = new StringBuilder().append('[');
240        appendTypes(b, classes, false);
241        return b.append(']').toString();
242    }
243
244    private static String getSignatureList(final List<MethodHandle> methods) {
245        final StringBuilder b = new StringBuilder().append('[');
246        final Iterator<MethodHandle> it = methods.iterator();
247        if(it.hasNext()) {
248            appendSig(b, it.next());
249            while(it.hasNext()) {
250                appendSig(b.append(", "), it.next());
251            }
252        }
253        return b.append(']').toString();
254    }
255
256    private static void appendSig(final StringBuilder b, final MethodHandle m) {
257        b.append('(');
258        appendTypes(b, m.type().parameterArray(), m.isVarargsCollector());
259        b.append(')');
260    }
261
262    private static void appendTypes(final StringBuilder b, final Class<?>[] classes, final boolean varArg) {
263        final int l = classes.length;
264        if(!varArg) {
265            if(l > 1) {
266                b.append(classes[1].getCanonicalName());
267                for(int i = 2; i < l; ++i) {
268                    b.append(", ").append(classes[i].getCanonicalName());
269                }
270            }
271        } else {
272            for(int i = 1; i < l - 1; ++i) {
273                b.append(classes[i].getCanonicalName()).append(", ");
274            }
275            b.append(classes[l - 1].getComponentType().getCanonicalName()).append("...");
276        }
277    }
278
279    private static Class<?> getCommonReturnType(final List<MethodHandle> methodHandles) {
280        final Iterator<MethodHandle> it = methodHandles.iterator();
281        Class<?> retType = it.next().type().returnType();
282        while(it.hasNext()) {
283            retType = InternalTypeUtilities.getCommonLosslessConversionType(retType, it.next().type().returnType());
284        }
285        return retType;
286    }
287}
288