Mercurial > jdk8-mips64-public > nashorn / changeset

     1.1 --- a/THIRD_PARTY_README	Thu Feb 14 13:01:52 2013 +0100
     1.2 +++ b/THIRD_PARTY_README	Thu Feb 14 13:22:26 2013 +0100
     1.3 @@ -67,3 +67,34 @@
     1.4  IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     1.5  OF SUCH DAMAGE.
     1.6  --- end of LICENSE ---
     1.7 +
     1.8 +%% This notice is provided with respect to Dynalink library which is included
     1.9 +with the Nashorn technology.
    1.10 +
    1.11 +--- begin of LICENSE ---
    1.12 +Copyright (c) 2009-2013, Attila Szegedi
    1.13 +
    1.14 +Redistribution and use in source and binary forms, with or without
    1.15 +modification, are permitted provided that the following conditions are
    1.16 +met:
    1.17 +* Redistributions of source code must retain the above copyright
    1.18 +  notice, this list of conditions and the following disclaimer.
    1.19 +* Redistributions in binary form must reproduce the above copyright
    1.20 +  notice, this list of conditions and the following disclaimer in the
    1.21 +  documentation and/or other materials provided with the distribution.
    1.22 +* Neither the name of the copyright holder nor the names of
    1.23 +  contributors may be used to endorse or promote products derived from
    1.24 +  this software without specific prior written permission.
    1.25 +
    1.26 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    1.27 +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    1.28 +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    1.29 +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
    1.30 +BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    1.31 +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    1.32 +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    1.33 +BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    1.34 +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    1.35 +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    1.36 +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    1.37 +--- end of LICENSE ---

     2.1 --- a/make/build.xml	Thu Feb 14 13:01:52 2013 +0100
     2.2 +++ b/make/build.xml	Thu Feb 14 13:22:26 2013 +0100
     2.3 @@ -54,19 +54,11 @@
     2.4  
     2.5    <target name="clean" depends="init, clean-nasgen">
     2.6      <delete includeemptydirs="true">
     2.7 -      <fileset dir="${build.dir}" excludes="${dynalink.dir.name}/**/*" erroronmissingdir="false"/>
     2.8 +      <fileset dir="${build.dir}" erroronmissingdir="false"/>
     2.9      </delete>
    2.10      <delete dir="${dist.dir}"/>
    2.11    </target>
    2.12  
    2.13 -  <target name="clean-dynalink">
    2.14 -    <delete dir="${dynalink.dir}"/>
    2.15 -  </target>
    2.16 -
    2.17 -  <target name="clean-all" depends="clean-dynalink, clean">
    2.18 -    <delete dir="${build.dir}"/>
    2.19 -  </target>
    2.20 -
    2.21    <!-- do it only if ASM is not available -->
    2.22    <target name="compile-asm" depends="prepare" unless="asm.available">
    2.23      <javac srcdir="${jdk.asm.src.dir}"
    2.24 @@ -79,29 +71,7 @@
    2.25             includeantruntime="false"/>
    2.26    </target>
    2.27  
    2.28 -  <target name="check-dynalink-uptodate" depends="init">
    2.29 -    <property name="versioned.dynalink.jar" value="${dynalink.dir}/dynalink-${dynalink.jar.version}.jar"/>
    2.30 -    <condition property="dynalink.uptodate">
    2.31 -      <and>
    2.32 -        <available file="${versioned.dynalink.jar}"/>
    2.33 -        <filesmatch file1="${versioned.dynalink.jar}" file2="${dynalink.jar}"/>
    2.34 -      </and>
    2.35 -    </condition>
    2.36 -  </target>
    2.37 -
    2.38 -  <target name="get-dynalink" depends="check-dynalink-uptodate" unless="dynalink.uptodate">
    2.39 -    <mkdir dir="${dynalink.dir}"/>
    2.40 -    <!-- Delete previous snapshots, if any -->
    2.41 -    <delete>
    2.42 -      <fileset dir="${dynalink.dir}" includes="*"/>
    2.43 -    </delete>
    2.44 -    <property name="dynalink.download.base.url" value="http://oss.sonatype.org/content/repositories/${dynalink.version.type}s/org/dynalang/dynalink/${dynalink.version}/dynalink-${dynalink.jar.version}"/>
    2.45 -    <get src="${dynalink.download.base.url}.jar" dest="${versioned.dynalink.jar}" usetimestamp="true"/>
    2.46 -    <get src="${dynalink.download.base.url}-sources.jar" dest="${dynalink.dir}/dynalink-sources.jar" usetimestamp="true"/>
    2.47 -    <copy file="${versioned.dynalink.jar}" tofile="${dynalink.jar}" overwrite="true"/>
    2.48 -  </target>
    2.49 -
    2.50 -  <target name="compile" depends="compile-asm, get-dynalink" description="Compiles nashorn">
    2.51 +  <target name="compile" depends="compile-asm" description="Compiles nashorn">
    2.52      <javac srcdir="${src.dir}"
    2.53             destdir="${build.classes.dir}"
    2.54             classpath="${javac.classpath}"
    2.55 @@ -126,6 +96,8 @@
    2.56      <copy todir="${build.classes.dir}/jdk/nashorn/tools/resources">
    2.57         <fileset dir="${src.dir}/jdk/nashorn/tools/resources/"/>
    2.58      </copy>
    2.59 +    <copy file="${src.dir}/jdk/internal/dynalink/support/messages.properties" todir="${build.classes.dir}/jdk/internal/dynalink/support"/>
    2.60 +
    2.61      <echo message="full=${nashorn.fullversion}" file="${build.classes.dir}/jdk/nashorn/internal/runtime/resources/version.properties"/>
    2.62      <echo file="${build.classes.dir}/jdk/nashorn/internal/runtime/resources/version.properties" append="true">${line.separator}</echo>
    2.63      <echo message="release=${nashorn.version}" file="${build.classes.dir}/jdk/nashorn/internal/runtime/resources/version.properties" append="true"/>
    2.64 @@ -134,7 +106,6 @@
    2.65    <target name="jar" depends="compile, run-nasgen" description="Creates nashorn.jar">
    2.66      <jar jarfile="${dist.jar}" manifest="${meta.inf.dir}/MANIFEST.MF" index="true" filesetmanifest="merge">
    2.67        <fileset dir="${build.classes.dir}"/>
    2.68 -      <zipfileset src="${dynalink.jar}"/>
    2.69        <manifest>
    2.70          <attribute name="Archiver-Version" value="n/a"/>
    2.71          <attribute name="Build-Jdk" value="${java.runtime.version}"/>
    2.72 @@ -152,12 +123,10 @@
    2.73      <javadoc destdir="${dist.javadoc.dir}" use="yes" overview="src/overview.html" windowtitle="${nashorn.product.name} ${nashorn.version}" additionalparam="-quiet" failonerror="true">
    2.74        <classpath>
    2.75          <pathelement location="${build.classes.dir}"/>
    2.76 -        <pathelement location="${dynalink.jar}"/>
    2.77        </classpath>
    2.78        <fileset dir="${src.dir}" includes="**/*.java"/>
    2.79        <fileset dir="${jdk.asm.src.dir}" includes="**/*.java"/>
    2.80        <link href="http://docs.oracle.com/javase/7/docs/api/"/>
    2.81 -      <link href="http://szegedi.github.com/dynalink/0.4/javadoc/"/>
    2.82        <!-- The following tags are used only in ASM sources - just ignore these -->
    2.83        <tag name="label" description="label tag in ASM sources" enabled="false"/>
    2.84        <tag name="linked" description="linked tag in ASM sources" enabled="false"/>

     3.1 --- a/make/nbproject/project.xml	Thu Feb 14 13:01:52 2013 +0100
     3.2 +++ b/make/nbproject/project.xml	Thu Feb 14 13:22:26 2013 +0100
     3.3 @@ -164,7 +164,6 @@
     3.4              </compilation-unit>
     3.5              <compilation-unit>
     3.6                  <package-root>../src</package-root>
     3.7 -                <classpath mode="compile">../build/dynalink/dynalink.jar</classpath>
     3.8                  <source-level>1.7</source-level>
     3.9              </compilation-unit>
    3.10              <compilation-unit>

     4.1 --- a/make/project.properties	Thu Feb 14 13:01:52 2013 +0100
     4.2 +++ b/make/project.properties	Thu Feb 14 13:22:26 2013 +0100
     4.3 @@ -87,23 +87,10 @@
     4.4   org.testng.reporters.EmailableReporter, \
     4.5   jdk.nashorn.internal.test.framework.JSJUnitReportReporter
     4.6  
     4.7 -# Define the version of Dynalink that is used. Version types are either
     4.8 -# 'snapshot' or 'release'. When it is 'snapshot', the version must have
     4.9 -# "-SNAPSHOT" suffix and the jar version will have a timestamp in it. When
    4.10 -# it's 'release', the version has no suffix, and the jar version is 
    4.11 -# identical to version - fun with Maven central.
    4.12 -dynalink.version=0.5-SNAPSHOT
    4.13 -dynalink.version.type=snapshot
    4.14 -dynalink.jar.version=0.5-20130109.113843-12
    4.15 -dynalink.dir.name=dynalink
    4.16 -dynalink.dir=build/${dynalink.dir.name}
    4.17 -dynalink.jar=${dynalink.dir}/dynalink.jar
    4.18 -
    4.19  javac.debug=true
    4.20  javac.encoding=ascii
    4.21  javac.classpath=\
    4.22 -    ${build.classes.dir}:\
    4.23 -    ${dynalink.jar}
    4.24 +    ${build.classes.dir}
    4.25  javac.test.classpath=\
    4.26      ${build.classes.dir}:\
    4.27      ${build.test.classes.dir}:\

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/src/jdk/internal/dynalink/CallSiteDescriptor.java	Thu Feb 14 13:22:26 2013 +0100
     5.3 @@ -0,0 +1,175 @@
     5.4 +/*
     5.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
     5.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     5.7 + *
     5.8 + * This code is free software; you can redistribute it and/or modify it
     5.9 + * under the terms of the GNU General Public License version 2 only, as
    5.10 + * published by the Free Software Foundation.  Oracle designates this
    5.11 + * particular file as subject to the "Classpath" exception as provided
    5.12 + * by Oracle in the LICENSE file that accompanied this code.
    5.13 + *
    5.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    5.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    5.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    5.17 + * version 2 for more details (a copy is included in the LICENSE file that
    5.18 + * accompanied this code).
    5.19 + *
    5.20 + * You should have received a copy of the GNU General Public License version
    5.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    5.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    5.23 + *
    5.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    5.25 + * or visit www.oracle.com if you need additional information or have any
    5.26 + * questions.
    5.27 + */
    5.28 +
    5.29 +/*
    5.30 + * This file is available under and governed by the GNU General Public
    5.31 + * License version 2 only, as published by the Free Software Foundation.
    5.32 + * However, the following notice accompanied the original version of this
    5.33 + * file, and Oracle licenses the original version of this file under the BSD
    5.34 + * license:
    5.35 + */
    5.36 +/*
    5.37 +   Copyright 2009-2013 Attila Szegedi
    5.38 +
    5.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
    5.40 +   and the BSD License (the "BSD License"), with licensee being free to
    5.41 +   choose either of the two at their discretion.
    5.42 +
    5.43 +   You may not use this file except in compliance with either the Apache
    5.44 +   License or the BSD License.
    5.45 +
    5.46 +   If you choose to use this file in compliance with the Apache License, the
    5.47 +   following notice applies to you:
    5.48 +
    5.49 +       You may obtain a copy of the Apache License at
    5.50 +
    5.51 +           http://www.apache.org/licenses/LICENSE-2.0
    5.52 +
    5.53 +       Unless required by applicable law or agreed to in writing, software
    5.54 +       distributed under the License is distributed on an "AS IS" BASIS,
    5.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
    5.56 +       implied. See the License for the specific language governing
    5.57 +       permissions and limitations under the License.
    5.58 +
    5.59 +   If you choose to use this file in compliance with the BSD License, the
    5.60 +   following notice applies to you:
    5.61 +
    5.62 +       Redistribution and use in source and binary forms, with or without
    5.63 +       modification, are permitted provided that the following conditions are
    5.64 +       met:
    5.65 +       * Redistributions of source code must retain the above copyright
    5.66 +         notice, this list of conditions and the following disclaimer.
    5.67 +       * Redistributions in binary form must reproduce the above copyright
    5.68 +         notice, this list of conditions and the following disclaimer in the
    5.69 +         documentation and/or other materials provided with the distribution.
    5.70 +       * Neither the name of the copyright holder nor the names of
    5.71 +         contributors may be used to endorse or promote products derived from
    5.72 +         this software without specific prior written permission.
    5.73 +
    5.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    5.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    5.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    5.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
    5.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    5.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    5.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    5.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    5.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    5.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    5.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    5.85 +*/
    5.86 +
    5.87 +package jdk.internal.dynalink;
    5.88 +
    5.89 +import java.lang.invoke.MethodHandles.Lookup;
    5.90 +import java.lang.invoke.MethodType;
    5.91 +import jdk.internal.dynalink.support.CallSiteDescriptorFactory;
    5.92 +
    5.93 +
    5.94 +/**
    5.95 + * An immutable descriptor of a call site. It is an immutable object that contains all the information about a call
    5.96 + * site: the class performing the lookups, the name of the method being invoked, and the method signature. The library
    5.97 + * has a default {@link CallSiteDescriptorFactory} for descriptors that you can use, or you can create your own
    5.98 + * descriptor classes, especially if you need to add further information (values passed in additional parameters to the
    5.99 + * bootstrap method) to them. Call site descriptors are used in this library in place of passing a real call site to
   5.100 + * guarding linkers so they aren't tempted to directly manipulate the call sites. The constructors of built-in
   5.101 + * {@link RelinkableCallSite} implementations all need a call site descriptor. Even if you create your own call site
   5.102 + * descriptors consider using {@link CallSiteDescriptorFactory#tokenizeName(String)} in your implementation.
   5.103 + *
   5.104 + * @author Attila Szegedi
   5.105 + */
   5.106 +public interface CallSiteDescriptor {
   5.107 +    /**
   5.108 +     * The index of the name token that will carry the operation scheme prefix (usually, "dyn").
   5.109 +     */
   5.110 +    public static final int SCHEME = 0;
   5.111 +    /**
   5.112 +     * The index of the name token that will usually carry the operation name.
   5.113 +     */
   5.114 +
   5.115 +    public static final int OPERATOR=1;
   5.116 +    /**
   5.117 +     * The index of the name token that will usually carry a name of an operand (of a property, method, etc.)
   5.118 +     */
   5.119 +
   5.120 +    public static final int NAME_OPERAND=2;
   5.121 +
   5.122 +    /**
   5.123 +     * Character used to delimit tokens in an call site name.
   5.124 +     */
   5.125 +    public static final String TOKEN_DELIMITER = ":";
   5.126 +
   5.127 +    /**
   5.128 +     * Character used to delimit operation names in a composite operation specification.
   5.129 +     */
   5.130 +    public static final String OPERATOR_DELIMITER = "|";
   5.131 +
   5.132 +    /**
   5.133 +     * Returns the number of tokens in the name of the method at the call site. Method names are tokenized with the
   5.134 +     * colon ":" character, i.e. "dyn:getProp:color" would be the name used to describe a method that retrieves the
   5.135 +     * property named "color" on the object it is invoked on.
   5.136 +     * @return the number of tokens in the name of the method at the call site.
   5.137 +     */
   5.138 +    public int getNameTokenCount();
   5.139 +
   5.140 +    /**
   5.141 +     * Returns the <i>i<sup>th</sup></i> token in the method name at the call site. Method names are tokenized with the
   5.142 +     * colon ":" character.
   5.143 +     * @param i the index of the token. Must be between 0 (inclusive) and {@link #getNameTokenCount()} (exclusive)
   5.144 +     * @throws IllegalArgumentException if the index is outside the allowed range.
   5.145 +     * @return the <i>i<sup>th</sup></i> token in the method name at the call site. The returned strings are interned.
   5.146 +     */
   5.147 +    public String getNameToken(int i);
   5.148 +
   5.149 +    /**
   5.150 +     * Returns the name of the method at the call site. Note that the object internally only stores the tokenized name,
   5.151 +     * and has to reconstruct the full name from tokens on each invocation.
   5.152 +     * @return the name of the method at the call site.
   5.153 +     */
   5.154 +    public String getName();
   5.155 +
   5.156 +    /**
   5.157 +     * The type of the method at the call site.
   5.158 +     *
   5.159 +     * @return type of the method at the call site.
   5.160 +     */
   5.161 +    public MethodType getMethodType();
   5.162 +
   5.163 +    /**
   5.164 +     * Returns the lookup passed to the bootstrap method.
   5.165 +     * @return the lookup passed to the bootstrap method.
   5.166 +     */
   5.167 +    public Lookup getLookup();
   5.168 +
   5.169 +    /**
   5.170 +     * Creates a new call site descriptor from this descriptor, which is identical to this, except it changes the method
   5.171 +     * type.
   5.172 +     *
   5.173 +     * @param newMethodType the new method type
   5.174 +     * @return a new call site descriptor, with the method type changed.
   5.175 +     */
   5.176 +    public CallSiteDescriptor changeMethodType(MethodType newMethodType);
   5.177 +
   5.178 +}
   5.179 \ No newline at end of file

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/jdk/internal/dynalink/ChainedCallSite.java	Thu Feb 14 13:22:26 2013 +0100
     6.3 @@ -0,0 +1,212 @@
     6.4 +/*
     6.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
     6.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     6.7 + *
     6.8 + * This code is free software; you can redistribute it and/or modify it
     6.9 + * under the terms of the GNU General Public License version 2 only, as
    6.10 + * published by the Free Software Foundation.  Oracle designates this
    6.11 + * particular file as subject to the "Classpath" exception as provided
    6.12 + * by Oracle in the LICENSE file that accompanied this code.
    6.13 + *
    6.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    6.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    6.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    6.17 + * version 2 for more details (a copy is included in the LICENSE file that
    6.18 + * accompanied this code).
    6.19 + *
    6.20 + * You should have received a copy of the GNU General Public License version
    6.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    6.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    6.23 + *
    6.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    6.25 + * or visit www.oracle.com if you need additional information or have any
    6.26 + * questions.
    6.27 + */
    6.28 +
    6.29 +/*
    6.30 + * This file is available under and governed by the GNU General Public
    6.31 + * License version 2 only, as published by the Free Software Foundation.
    6.32 + * However, the following notice accompanied the original version of this
    6.33 + * file, and Oracle licenses the original version of this file under the BSD
    6.34 + * license:
    6.35 + */
    6.36 +/*
    6.37 +   Copyright 2009-2013 Attila Szegedi
    6.38 +
    6.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
    6.40 +   and the BSD License (the "BSD License"), with licensee being free to
    6.41 +   choose either of the two at their discretion.
    6.42 +
    6.43 +   You may not use this file except in compliance with either the Apache
    6.44 +   License or the BSD License.
    6.45 +
    6.46 +   If you choose to use this file in compliance with the Apache License, the
    6.47 +   following notice applies to you:
    6.48 +
    6.49 +       You may obtain a copy of the Apache License at
    6.50 +
    6.51 +           http://www.apache.org/licenses/LICENSE-2.0
    6.52 +
    6.53 +       Unless required by applicable law or agreed to in writing, software
    6.54 +       distributed under the License is distributed on an "AS IS" BASIS,
    6.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
    6.56 +       implied. See the License for the specific language governing
    6.57 +       permissions and limitations under the License.
    6.58 +
    6.59 +   If you choose to use this file in compliance with the BSD License, the
    6.60 +   following notice applies to you:
    6.61 +
    6.62 +       Redistribution and use in source and binary forms, with or without
    6.63 +       modification, are permitted provided that the following conditions are
    6.64 +       met:
    6.65 +       * Redistributions of source code must retain the above copyright
    6.66 +         notice, this list of conditions and the following disclaimer.
    6.67 +       * Redistributions in binary form must reproduce the above copyright
    6.68 +         notice, this list of conditions and the following disclaimer in the
    6.69 +         documentation and/or other materials provided with the distribution.
    6.70 +       * Neither the name of the copyright holder nor the names of
    6.71 +         contributors may be used to endorse or promote products derived from
    6.72 +         this software without specific prior written permission.
    6.73 +
    6.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    6.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    6.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    6.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
    6.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    6.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    6.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    6.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    6.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    6.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    6.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    6.85 +*/
    6.86 +
    6.87 +package jdk.internal.dynalink;
    6.88 +
    6.89 +import java.lang.invoke.MethodHandle;
    6.90 +import java.lang.invoke.MethodHandles;
    6.91 +import java.lang.invoke.MethodType;
    6.92 +import java.util.Iterator;
    6.93 +import java.util.LinkedList;
    6.94 +import java.util.concurrent.atomic.AtomicReference;
    6.95 +import jdk.internal.dynalink.linker.GuardedInvocation;
    6.96 +import jdk.internal.dynalink.support.AbstractRelinkableCallSite;
    6.97 +
    6.98 +
    6.99 +/**
   6.100 + * A relinkable call site that maintains a chain of linked method handles. In the default implementation, up to 8 method
   6.101 + * handles can be chained, cascading from one to the other through
   6.102 + * {@link MethodHandles#guardWithTest(MethodHandle, MethodHandle, MethodHandle)}. When this call site has to link a new
   6.103 + * method handle and the length of the chain is already at the maximum, it will throw away the oldest method handle.
   6.104 + * Switchpoint-invalidated handles in the chain are removed eagerly (on each linking request, and whenever a
   6.105 + * switchpoint-invalidated method handle is traversed during invocation). There is currently no profiling
   6.106 + * attached to the handles in the chain, so they are never reordered based on usage; the most recently linked method
   6.107 + * handle is always at the start of the chain.
   6.108 + */
   6.109 +public class ChainedCallSite extends AbstractRelinkableCallSite {
   6.110 +    private final AtomicReference<LinkedList<GuardedInvocation>> invocations = new AtomicReference<>();
   6.111 +
   6.112 +    /**
   6.113 +     * Creates a new chained call site.
   6.114 +     * @param descriptor the descriptor for the call site.
   6.115 +     */
   6.116 +    public ChainedCallSite(CallSiteDescriptor descriptor) {
   6.117 +        super(descriptor);
   6.118 +    }
   6.119 +
   6.120 +    /**
   6.121 +     * The maximum number of method handles in the chain. Defaults to 8. You can override it in a subclass if you need
   6.122 +     * to change the value. If your override returns a value less than 1, the code will break.
   6.123 +     * @return the maximum number of method handles in the chain.
   6.124 +     */
   6.125 +    @SuppressWarnings("static-method")
   6.126 +    protected int getMaxChainLength() {
   6.127 +        return 8;
   6.128 +    }
   6.129 +
   6.130 +    @Override
   6.131 +    public void relink(GuardedInvocation guardedInvocation, MethodHandle fallback) {
   6.132 +        relinkInternal(guardedInvocation, fallback, false);
   6.133 +    }
   6.134 +
   6.135 +    @Override
   6.136 +    public void resetAndRelink(GuardedInvocation guardedInvocation, MethodHandle fallback) {
   6.137 +        relinkInternal(guardedInvocation, fallback, true);
   6.138 +    }
   6.139 +
   6.140 +    private MethodHandle relinkInternal(GuardedInvocation invocation, MethodHandle relink, boolean reset) {
   6.141 +        final LinkedList<GuardedInvocation> currentInvocations = invocations.get();
   6.142 +        @SuppressWarnings({ "unchecked", "rawtypes" })
   6.143 +        final LinkedList<GuardedInvocation> newInvocations =
   6.144 +            currentInvocations == null || reset ? new LinkedList<>() : (LinkedList)currentInvocations.clone();
   6.145 +
   6.146 +        // First, prune the chain of invalidated switchpoints.
   6.147 +        for(Iterator<GuardedInvocation> it = newInvocations.iterator(); it.hasNext();) {
   6.148 +            if(it.next().hasBeenInvalidated()) {
   6.149 +                it.remove();
   6.150 +            }
   6.151 +        }
   6.152 +
   6.153 +        // prune() is allowed to invoke this method with invocation == null meaning we're just pruning the chain and not
   6.154 +        // adding any new invocations to it.
   6.155 +        if(invocation != null) {
   6.156 +            // Remove oldest entry if we're at max length
   6.157 +            if(newInvocations.size() == getMaxChainLength()) {
   6.158 +                newInvocations.removeFirst();
   6.159 +            }
   6.160 +            newInvocations.addLast(invocation);
   6.161 +        }
   6.162 +
   6.163 +        // prune-and-invoke is used as the fallback for invalidated switchpoints. If a switchpoint gets invalidated, we
   6.164 +        // rebuild the chain and get rid of all invalidated switchpoints instead of letting them linger.
   6.165 +        final MethodHandle pruneAndInvoke = makePruneAndInvokeMethod(relink);
   6.166 +
   6.167 +        // Fold the new chain
   6.168 +        MethodHandle target = relink;
   6.169 +        for(GuardedInvocation inv: newInvocations) {
   6.170 +            target = inv.compose(pruneAndInvoke, target);
   6.171 +        }
   6.172 +
   6.173 +        // If nobody else updated the call site while we were rebuilding the chain, set the target to our chain. In case
   6.174 +        // we lost the race for multithreaded update, just do nothing. Either the other thread installed the same thing
   6.175 +        // we wanted to install, or otherwise, we'll be asked to relink again.
   6.176 +        if(invocations.compareAndSet(currentInvocations, newInvocations)) {
   6.177 +            setTarget(target);
   6.178 +        }
   6.179 +        return target;
   6.180 +    }
   6.181 +
   6.182 +    /**
   6.183 +     * Creates a method that rebuilds our call chain, pruning it of any invalidated switchpoints, and then invokes that
   6.184 +     * chain.
   6.185 +     * @param relink the ultimate fallback for the chain (the {@code DynamicLinker}'s relink).
   6.186 +     * @return a method handle for prune-and-invoke
   6.187 +     */
   6.188 +    private MethodHandle makePruneAndInvokeMethod(MethodHandle relink) {
   6.189 +        // Bind prune to (this, relink)
   6.190 +        final MethodHandle boundPrune = MethodHandles.insertArguments(PRUNE, 0, this, relink);
   6.191 +        // Make it ignore all incoming arguments
   6.192 +        final MethodHandle ignoreArgsPrune = MethodHandles.dropArguments(boundPrune, 0, type().parameterList());
   6.193 +        // Invoke prune, then invoke the call site target with original arguments
   6.194 +        return MethodHandles.foldArguments(MethodHandles.exactInvoker(type()), ignoreArgsPrune);
   6.195 +    }
   6.196 +
   6.197 +    @SuppressWarnings("unused")
   6.198 +    private MethodHandle prune(MethodHandle relink) {
   6.199 +        return relinkInternal(null, relink, false);
   6.200 +    }
   6.201 +
   6.202 +    private static final MethodHandle PRUNE;
   6.203 +    static {
   6.204 +        try {
   6.205 +            PRUNE = MethodHandles.lookup().findSpecial(ChainedCallSite.class, "prune", MethodType.methodType(
   6.206 +                    MethodHandle.class, MethodHandle.class), ChainedCallSite.class);
   6.207 +        // NOTE: using two catch blocks so we don't introduce a reference to 1.7 ReflectiveOperationException, allowing
   6.208 +        // Dynalink to be used on 1.6 JVMs with Remi's backport library.
   6.209 +        } catch(IllegalAccessException e) {
   6.210 +            throw new AssertionError(e.getMessage(), e); // Can not happen
   6.211 +        } catch(NoSuchMethodException e) {
   6.212 +            throw new AssertionError(e.getMessage(), e); // Can not happen
   6.213 +        }
   6.214 +    }
   6.215 +}
   6.216 \ No newline at end of file

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/jdk/internal/dynalink/DefaultBootstrapper.java	Thu Feb 14 13:22:26 2013 +0100
     7.3 @@ -0,0 +1,144 @@
     7.4 +/*
     7.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
     7.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     7.7 + *
     7.8 + * This code is free software; you can redistribute it and/or modify it
     7.9 + * under the terms of the GNU General Public License version 2 only, as
    7.10 + * published by the Free Software Foundation.  Oracle designates this
    7.11 + * particular file as subject to the "Classpath" exception as provided
    7.12 + * by Oracle in the LICENSE file that accompanied this code.
    7.13 + *
    7.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    7.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    7.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    7.17 + * version 2 for more details (a copy is included in the LICENSE file that
    7.18 + * accompanied this code).
    7.19 + *
    7.20 + * You should have received a copy of the GNU General Public License version
    7.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    7.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    7.23 + *
    7.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    7.25 + * or visit www.oracle.com if you need additional information or have any
    7.26 + * questions.
    7.27 + */
    7.28 +
    7.29 +/*
    7.30 + * This file is available under and governed by the GNU General Public
    7.31 + * License version 2 only, as published by the Free Software Foundation.
    7.32 + * However, the following notice accompanied the original version of this
    7.33 + * file, and Oracle licenses the original version of this file under the BSD
    7.34 + * license:
    7.35 + */
    7.36 +/*
    7.37 +   Copyright 2009-2013 Attila Szegedi
    7.38 +
    7.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
    7.40 +   and the BSD License (the "BSD License"), with licensee being free to
    7.41 +   choose either of the two at their discretion.
    7.42 +
    7.43 +   You may not use this file except in compliance with either the Apache
    7.44 +   License or the BSD License.
    7.45 +
    7.46 +   If you choose to use this file in compliance with the Apache License, the
    7.47 +   following notice applies to you:
    7.48 +
    7.49 +       You may obtain a copy of the Apache License at
    7.50 +
    7.51 +           http://www.apache.org/licenses/LICENSE-2.0
    7.52 +
    7.53 +       Unless required by applicable law or agreed to in writing, software
    7.54 +       distributed under the License is distributed on an "AS IS" BASIS,
    7.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
    7.56 +       implied. See the License for the specific language governing
    7.57 +       permissions and limitations under the License.
    7.58 +
    7.59 +   If you choose to use this file in compliance with the BSD License, the
    7.60 +   following notice applies to you:
    7.61 +
    7.62 +       Redistribution and use in source and binary forms, with or without
    7.63 +       modification, are permitted provided that the following conditions are
    7.64 +       met:
    7.65 +       * Redistributions of source code must retain the above copyright
    7.66 +         notice, this list of conditions and the following disclaimer.
    7.67 +       * Redistributions in binary form must reproduce the above copyright
    7.68 +         notice, this list of conditions and the following disclaimer in the
    7.69 +         documentation and/or other materials provided with the distribution.
    7.70 +       * Neither the name of the copyright holder nor the names of
    7.71 +         contributors may be used to endorse or promote products derived from
    7.72 +         this software without specific prior written permission.
    7.73 +
    7.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    7.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    7.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    7.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
    7.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    7.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    7.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    7.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    7.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    7.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    7.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    7.85 +*/
    7.86 +
    7.87 +package jdk.internal.dynalink;
    7.88 +
    7.89 +import java.lang.invoke.CallSite;
    7.90 +import java.lang.invoke.MethodHandles;
    7.91 +import java.lang.invoke.MethodType;
    7.92 +import jdk.internal.dynalink.support.CallSiteDescriptorFactory;
    7.93 +
    7.94 +
    7.95 +/**
    7.96 + * A convenience default bootstrapper that exposes static bootstrap methods which language runtimes that need the very
    7.97 + * default behavior can use with minimal setup. When first referenced, it will create a dynamic linker with default
    7.98 + * settings for the {@link DynamicLinkerFactory}, and its bootstrap methods will create {@link MonomorphicCallSite} for
    7.99 + * all call sites. It has two bootstrap methods: one creates call sites that use the
   7.100 + * {@link MethodHandles#publicLookup()} as the lookup for all call sites and disregard the one passed in as the caller,
   7.101 + * and one that just uses the passed caller as the lookup scope. Using the public lookup one is advised if your language
   7.102 + * runtime has no concept of interacting with Java visibility scopes, as it results in a more lightweight runtime
   7.103 + * information.
   7.104 + *
   7.105 + * @author Attila Szegedi
   7.106 + */
   7.107 +public class DefaultBootstrapper {
   7.108 +    private static final DynamicLinker dynamicLinker = new DynamicLinkerFactory().createLinker();
   7.109 +
   7.110 +    private DefaultBootstrapper() {
   7.111 +    }
   7.112 +
   7.113 +    /**
   7.114 +     * Use this method as your bootstrap method (see the documentation of the java.lang.invoke package for how to do
   7.115 +     * this). In case your language runtime doesn't have a concept of interaction with Java access scopes, you might
   7.116 +     * want to consider using
   7.117 +     * {@link #publicBootstrap(java.lang.invoke.MethodHandles.Lookup, String, MethodType)} instead.
   7.118 +     *
   7.119 +     * @param caller the caller's lookup
   7.120 +     * @param name the name of the method at the call site
   7.121 +     * @param type the method signature at the call site
   7.122 +     * @return a new {@link MonomorphicCallSite} linked with the default dynamic linker.
   7.123 +     */
   7.124 +    public static CallSite bootstrap(MethodHandles.Lookup caller, String name, MethodType type) {
   7.125 +        return bootstrapInternal(caller, name, type);
   7.126 +    }
   7.127 +
   7.128 +    /**
   7.129 +     * Use this method as your bootstrap method (see the documentation of the java.lang.invoke package for how to do
   7.130 +     * this) when your language runtime doesn't have a concept of interaction with Java access scopes. If you need to
   7.131 +     * preserve the different caller Lookup objects in the call sites, use
   7.132 +     * {@link #bootstrap(java.lang.invoke.MethodHandles.Lookup, String, MethodType)} instead
   7.133 +     *
   7.134 +     * @param caller the caller's lookup. It is ignored as the call sites will be created with
   7.135 +     * {@link MethodHandles#publicLookup()} instead.
   7.136 +     * @param name the name of the method at the call site
   7.137 +     * @param type the method signature at the call site
   7.138 +     * @return a new {@link MonomorphicCallSite} linked with the default dynamic linker.
   7.139 +     */
   7.140 +    public static CallSite publicBootstrap(@SuppressWarnings("unused") MethodHandles.Lookup caller, String name, MethodType type) {
   7.141 +        return bootstrapInternal(MethodHandles.publicLookup(), name, type);
   7.142 +    }
   7.143 +
   7.144 +    private static CallSite bootstrapInternal(MethodHandles.Lookup caller, String name, MethodType type) {
   7.145 +        return dynamicLinker.link(new MonomorphicCallSite(CallSiteDescriptorFactory.create(caller, name, type)));
   7.146 +    }
   7.147 +}
   7.148 \ No newline at end of file

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/jdk/internal/dynalink/DynamicLinker.java	Thu Feb 14 13:22:26 2013 +0100
     8.3 @@ -0,0 +1,281 @@
     8.4 +/*
     8.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
     8.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.7 + *
     8.8 + * This code is free software; you can redistribute it and/or modify it
     8.9 + * under the terms of the GNU General Public License version 2 only, as
    8.10 + * published by the Free Software Foundation.  Oracle designates this
    8.11 + * particular file as subject to the "Classpath" exception as provided
    8.12 + * by Oracle in the LICENSE file that accompanied this code.
    8.13 + *
    8.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    8.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    8.17 + * version 2 for more details (a copy is included in the LICENSE file that
    8.18 + * accompanied this code).
    8.19 + *
    8.20 + * You should have received a copy of the GNU General Public License version
    8.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    8.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    8.23 + *
    8.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    8.25 + * or visit www.oracle.com if you need additional information or have any
    8.26 + * questions.
    8.27 + */
    8.28 +
    8.29 +/*
    8.30 + * This file is available under and governed by the GNU General Public
    8.31 + * License version 2 only, as published by the Free Software Foundation.
    8.32 + * However, the following notice accompanied the original version of this
    8.33 + * file, and Oracle licenses the original version of this file under the BSD
    8.34 + * license:
    8.35 + */
    8.36 +/*
    8.37 +   Copyright 2009-2013 Attila Szegedi
    8.38 +
    8.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
    8.40 +   and the BSD License (the "BSD License"), with licensee being free to
    8.41 +   choose either of the two at their discretion.
    8.42 +
    8.43 +   You may not use this file except in compliance with either the Apache
    8.44 +   License or the BSD License.
    8.45 +
    8.46 +   If you choose to use this file in compliance with the Apache License, the
    8.47 +   following notice applies to you:
    8.48 +
    8.49 +       You may obtain a copy of the Apache License at
    8.50 +
    8.51 +           http://www.apache.org/licenses/LICENSE-2.0
    8.52 +
    8.53 +       Unless required by applicable law or agreed to in writing, software
    8.54 +       distributed under the License is distributed on an "AS IS" BASIS,
    8.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
    8.56 +       implied. See the License for the specific language governing
    8.57 +       permissions and limitations under the License.
    8.58 +
    8.59 +   If you choose to use this file in compliance with the BSD License, the
    8.60 +   following notice applies to you:
    8.61 +
    8.62 +       Redistribution and use in source and binary forms, with or without
    8.63 +       modification, are permitted provided that the following conditions are
    8.64 +       met:
    8.65 +       * Redistributions of source code must retain the above copyright
    8.66 +         notice, this list of conditions and the following disclaimer.
    8.67 +       * Redistributions in binary form must reproduce the above copyright
    8.68 +         notice, this list of conditions and the following disclaimer in the
    8.69 +         documentation and/or other materials provided with the distribution.
    8.70 +       * Neither the name of the copyright holder nor the names of
    8.71 +         contributors may be used to endorse or promote products derived from
    8.72 +         this software without specific prior written permission.
    8.73 +
    8.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    8.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    8.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    8.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
    8.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    8.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    8.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    8.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    8.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    8.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    8.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    8.85 +*/
    8.86 +
    8.87 +package jdk.internal.dynalink;
    8.88 +
    8.89 +import java.lang.invoke.MethodHandle;
    8.90 +import java.lang.invoke.MethodHandles;
    8.91 +import java.lang.invoke.MethodType;
    8.92 +import java.lang.invoke.MutableCallSite;
    8.93 +import java.util.List;
    8.94 +import jdk.internal.dynalink.linker.GuardedInvocation;
    8.95 +import jdk.internal.dynalink.linker.GuardingDynamicLinker;
    8.96 +import jdk.internal.dynalink.linker.LinkRequest;
    8.97 +import jdk.internal.dynalink.linker.LinkerServices;
    8.98 +import jdk.internal.dynalink.support.CallSiteDescriptorFactory;
    8.99 +import jdk.internal.dynalink.support.LinkRequestImpl;
   8.100 +import jdk.internal.dynalink.support.Lookup;
   8.101 +import jdk.internal.dynalink.support.RuntimeContextLinkRequestImpl;
   8.102 +
   8.103 +
   8.104 +/**
   8.105 + * The linker for {@link RelinkableCallSite} objects. Users of it (scripting frameworks and language runtimes) have to
   8.106 + * create a linker using the {@link DynamicLinkerFactory} and invoke its link method from the invokedynamic bootstrap
   8.107 + * methods to set the target of all the call sites in the code they generate. Usual usage would be to create one class
   8.108 + * per language runtime to contain one linker instance as:
   8.109 + *
   8.110 + * <pre>
   8.111 + * class MyLanguageRuntime {
   8.112 + *     private static final GuardingDynamicLinker myLanguageLinker = new MyLanguageLinker();
   8.113 + *     private static final DynamicLinker dynamicLinker = createDynamicLinker();
   8.114 + *
   8.115 + *     private static DynamicLinker createDynamicLinker() {
   8.116 + *         final DynamicLinkerFactory factory = new DynamicLinkerFactory();
   8.117 + *         factory.setPrioritizedLinker(myLanguageLinker);
   8.118 + *         return factory.createLinker();
   8.119 + *     }
   8.120 + *
   8.121 + *     public static CallSite bootstrap(MethodHandles.Lookup caller, String name, MethodType type) {
   8.122 + *         return dynamicLinker.link(new MonomorphicCallSite(CallSiteDescriptorFactory.create(lookup, name, type)));
   8.123 + *     }
   8.124 + * }
   8.125 + * </pre>
   8.126 + *
   8.127 + * Note how there are three components you will need to provide here:
   8.128 + * <ul>
   8.129 + * <li>You're expected to provide a {@link GuardingDynamicLinker} for your own language. If your runtime doesn't
   8.130 + * have its own language and/or object model (i.e. it's a generic scripting shell), you don't need to implement a
   8.131 + * dynamic linker; you would simply not invoke the {@code setPrioritizedLinker} method on the factory, or even better,
   8.132 + * simply use {@link DefaultBootstrapper}.</li>
   8.133 + * <li>The performance of the programs can depend on your choice of the class to represent call sites. The above
   8.134 + * example used {@link MonomorphicCallSite}, but you might want to use {@link ChainedCallSite} instead. You'll need to
   8.135 + * experiment and decide what fits your language runtime the best. You can subclass either of these or roll your own if
   8.136 + * you need to.</li>
   8.137 + * <li>You also need to provide {@link CallSiteDescriptor}s to your call sites. They are immutable objects that contain
   8.138 + * all the information about the call site: the class performing the lookups, the name of the method being invoked, and
   8.139 + * the method signature. The library has a default {@link CallSiteDescriptorFactory} for descriptors that you can use,
   8.140 + * or you can create your own descriptor classes, especially if you need to add further information (values passed in
   8.141 + * additional parameters to the bootstrap method) to them.</li>
   8.142 + * </ul>
   8.143 + *
   8.144 + * @author Attila Szegedi
   8.145 + */
   8.146 +public class DynamicLinker {
   8.147 +
   8.148 +    private static final String CLASS_NAME = DynamicLinker.class.getName();
   8.149 +    private static final String RELINK_METHOD_NAME = "relink";
   8.150 +
   8.151 +    private final LinkerServices linkerServices;
   8.152 +    private final int runtimeContextArgCount;
   8.153 +    private final boolean syncOnRelink;
   8.154 +    private final int unstableRelinkThreshold;
   8.155 +
   8.156 +    /**
   8.157 +     * Creates a new dynamic linker.
   8.158 +     *
   8.159 +     * @param linkerServices the linkerServices used by the linker, created by the factory.
   8.160 +     * @param runtimeContextArgCount see {@link DynamicLinkerFactory#setRuntimeContextArgCount(int)}
   8.161 +     */
   8.162 +    DynamicLinker(LinkerServices linkerServices, int runtimeContextArgCount, boolean syncOnRelink,
   8.163 +            int unstableRelinkThreshold) {
   8.164 +        if(runtimeContextArgCount < 0) {
   8.165 +            throw new IllegalArgumentException("runtimeContextArgCount < 0");
   8.166 +        }
   8.167 +        if(unstableRelinkThreshold < 0) {
   8.168 +            throw new IllegalArgumentException("unstableRelinkThreshold < 0");
   8.169 +        }
   8.170 +        this.runtimeContextArgCount = runtimeContextArgCount;
   8.171 +        this.linkerServices = linkerServices;
   8.172 +        this.syncOnRelink = syncOnRelink;
   8.173 +        this.unstableRelinkThreshold = unstableRelinkThreshold;
   8.174 +    }
   8.175 +
   8.176 +    /**
   8.177 +     * Links an invokedynamic call site. It will install a method handle into the call site that invokes the relinking
   8.178 +     * mechanism of this linker. Next time the call site is invoked, it will be linked for the actual arguments it was
   8.179 +     * invoked with.
   8.180 +     *
   8.181 +     * @param callSite the call site to link.
   8.182 +     * @return the callSite, for easy call chaining.
   8.183 +     */
   8.184 +    public <T extends RelinkableCallSite> T link(final T callSite) {
   8.185 +        callSite.initialize(createRelinkAndInvokeMethod(callSite, 0));
   8.186 +        return callSite;
   8.187 +    }
   8.188 +
   8.189 +    /**
   8.190 +     * Returns the object representing the lower level linker services of this class that are normally exposed to
   8.191 +     * individual language-specific linkers. While as a user of this class you normally only care about the
   8.192 +     * {@link #link(RelinkableCallSite)} method, in certain circumstances you might want to use the lower level services
   8.193 +     * directly; either to lookup specific method handles, to access the type converters, and so on.
   8.194 +     * @return the object representing the linker services of this class.
   8.195 +     */
   8.196 +    public LinkerServices getLinkerServices() {
   8.197 +        return linkerServices;
   8.198 +    }
   8.199 +
   8.200 +    private static final MethodHandle RELINK = Lookup.findOwnSpecial(MethodHandles.lookup(), RELINK_METHOD_NAME,
   8.201 +            MethodHandle.class, RelinkableCallSite.class, int.class, Object[].class);
   8.202 +
   8.203 +    private MethodHandle createRelinkAndInvokeMethod(final RelinkableCallSite callSite, int relinkCount) {
   8.204 +        // Make a bound MH of invoke() for this linker and call site
   8.205 +        final MethodHandle boundRelinker = MethodHandles.insertArguments(RELINK, 0, this, callSite, Integer.valueOf(
   8.206 +                relinkCount));
   8.207 +        // Make a MH that gathers all arguments to the invocation into an Object[]
   8.208 +        final MethodType type = callSite.getDescriptor().getMethodType();
   8.209 +        final MethodHandle collectingRelinker = boundRelinker.asCollector(Object[].class, type.parameterCount());
   8.210 +        return MethodHandles.foldArguments(MethodHandles.exactInvoker(type), collectingRelinker.asType(
   8.211 +                type.changeReturnType(MethodHandle.class)));
   8.212 +    }
   8.213 +
   8.214 +    /**
   8.215 +     * Relinks a call site conforming to the invocation arguments.
   8.216 +     *
   8.217 +     * @param callSite the call site itself
   8.218 +     * @param arguments arguments to the invocation
   8.219 +     * @return return the method handle for the invocation
   8.220 +     * @throws Exception rethrows any exception thrown by the linkers
   8.221 +     */
   8.222 +    @SuppressWarnings("unused")
   8.223 +    private MethodHandle relink(RelinkableCallSite callSite, int relinkCount, Object... arguments) throws Exception {
   8.224 +        final CallSiteDescriptor callSiteDescriptor = callSite.getDescriptor();
   8.225 +        final boolean unstableDetectionEnabled = unstableRelinkThreshold > 0;
   8.226 +        final boolean callSiteUnstable = unstableDetectionEnabled && relinkCount >= unstableRelinkThreshold;
   8.227 +        final LinkRequest linkRequest =
   8.228 +                runtimeContextArgCount == 0 ? new LinkRequestImpl(callSiteDescriptor, callSiteUnstable, arguments)
   8.229 +                        : new RuntimeContextLinkRequestImpl(callSiteDescriptor, callSiteUnstable, arguments,
   8.230 +                                runtimeContextArgCount);
   8.231 +
   8.232 +        // Find a suitable method handle with a guard
   8.233 +        GuardedInvocation guardedInvocation = linkerServices.getGuardedInvocation(linkRequest);
   8.234 +
   8.235 +        // None found - throw an exception
   8.236 +        if(guardedInvocation == null) {
   8.237 +            throw new NoSuchDynamicMethodException(callSiteDescriptor.toString());
   8.238 +        }
   8.239 +
   8.240 +        // If our call sites have a runtime context, and the linker produced a context-stripped invocation, adapt the
   8.241 +        // produced invocation into contextual invocation (by dropping the context...)
   8.242 +        if(runtimeContextArgCount > 0) {
   8.243 +            final MethodType origType = callSiteDescriptor.getMethodType();
   8.244 +            final MethodHandle invocation = guardedInvocation.getInvocation();
   8.245 +            if(invocation.type().parameterCount() == origType.parameterCount() - runtimeContextArgCount) {
   8.246 +                final List<Class<?>> prefix = origType.parameterList().subList(1, runtimeContextArgCount + 1);
   8.247 +                final MethodHandle guard = guardedInvocation.getGuard();
   8.248 +                guardedInvocation = guardedInvocation.dropArguments(1, prefix);
   8.249 +            }
   8.250 +        }
   8.251 +
   8.252 +        if(unstableDetectionEnabled && relinkCount <= unstableRelinkThreshold && relinkCount++ == unstableRelinkThreshold) {
   8.253 +            // Note that we'll increase the relinkCount until threshold+1 and not increase it beyond that. Threshold+1
   8.254 +            // is treated as a special value to signal that resetAndRelink has already executed once for the unstable
   8.255 +            // call site; we only want the call site to throw away its current linkage once, when it transitions to
   8.256 +            // unstable.
   8.257 +            callSite.resetAndRelink(guardedInvocation, createRelinkAndInvokeMethod(callSite, relinkCount));
   8.258 +        } else {
   8.259 +            callSite.relink(guardedInvocation, createRelinkAndInvokeMethod(callSite, relinkCount));
   8.260 +        }
   8.261 +        if(syncOnRelink) {
   8.262 +            MutableCallSite.syncAll(new MutableCallSite[] { (MutableCallSite)callSite });
   8.263 +        }
   8.264 +        return guardedInvocation.getInvocation();
   8.265 +    }
   8.266 +
   8.267 +    /**
   8.268 +     * Returns a stack trace element describing the location of the call site currently being relinked on the current
   8.269 +     * thread. The operation internally creates a Throwable object and inspects its stack trace, so it's potentially
   8.270 +     * expensive. The recommended usage for it is in writing diagnostics code.
   8.271 +     * @return a stack trace element describing the location of the call site currently being relinked, or null if it is
   8.272 +     * not invoked while a call site is being relinked.
   8.273 +     */
   8.274 +    public static StackTraceElement getRelinkedCallSiteLocation() {
   8.275 +        final StackTraceElement[] trace = new Throwable().getStackTrace();
   8.276 +        for(int i = 0; i < trace.length - 1; ++i) {
   8.277 +            final StackTraceElement frame = trace[i];
   8.278 +            if(RELINK_METHOD_NAME.equals(frame.getMethodName()) && CLASS_NAME.equals(frame.getClassName())) {
   8.279 +                return trace[i + 1];
   8.280 +            }
   8.281 +        }
   8.282 +        return null;
   8.283 +    }
   8.284 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/src/jdk/internal/dynalink/DynamicLinkerFactory.java	Thu Feb 14 13:22:26 2013 +0100
     9.3 @@ -0,0 +1,311 @@
     9.4 +/*
     9.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
     9.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     9.7 + *
     9.8 + * This code is free software; you can redistribute it and/or modify it
     9.9 + * under the terms of the GNU General Public License version 2 only, as
    9.10 + * published by the Free Software Foundation.  Oracle designates this
    9.11 + * particular file as subject to the "Classpath" exception as provided
    9.12 + * by Oracle in the LICENSE file that accompanied this code.
    9.13 + *
    9.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    9.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    9.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    9.17 + * version 2 for more details (a copy is included in the LICENSE file that
    9.18 + * accompanied this code).
    9.19 + *
    9.20 + * You should have received a copy of the GNU General Public License version
    9.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    9.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    9.23 + *
    9.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    9.25 + * or visit www.oracle.com if you need additional information or have any
    9.26 + * questions.
    9.27 + */
    9.28 +
    9.29 +/*
    9.30 + * This file is available under and governed by the GNU General Public
    9.31 + * License version 2 only, as published by the Free Software Foundation.
    9.32 + * However, the following notice accompanied the original version of this
    9.33 + * file, and Oracle licenses the original version of this file under the BSD
    9.34 + * license:
    9.35 + */
    9.36 +/*
    9.37 +   Copyright 2009-2013 Attila Szegedi
    9.38 +
    9.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
    9.40 +   and the BSD License (the "BSD License"), with licensee being free to
    9.41 +   choose either of the two at their discretion.
    9.42 +
    9.43 +   You may not use this file except in compliance with either the Apache
    9.44 +   License or the BSD License.
    9.45 +
    9.46 +   If you choose to use this file in compliance with the Apache License, the
    9.47 +   following notice applies to you:
    9.48 +
    9.49 +       You may obtain a copy of the Apache License at
    9.50 +
    9.51 +           http://www.apache.org/licenses/LICENSE-2.0
    9.52 +
    9.53 +       Unless required by applicable law or agreed to in writing, software
    9.54 +       distributed under the License is distributed on an "AS IS" BASIS,
    9.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
    9.56 +       implied. See the License for the specific language governing
    9.57 +       permissions and limitations under the License.
    9.58 +
    9.59 +   If you choose to use this file in compliance with the BSD License, the
    9.60 +   following notice applies to you:
    9.61 +
    9.62 +       Redistribution and use in source and binary forms, with or without
    9.63 +       modification, are permitted provided that the following conditions are
    9.64 +       met:
    9.65 +       * Redistributions of source code must retain the above copyright
    9.66 +         notice, this list of conditions and the following disclaimer.
    9.67 +       * Redistributions in binary form must reproduce the above copyright
    9.68 +         notice, this list of conditions and the following disclaimer in the
    9.69 +         documentation and/or other materials provided with the distribution.
    9.70 +       * Neither the name of the copyright holder nor the names of
    9.71 +         contributors may be used to endorse or promote products derived from
    9.72 +         this software without specific prior written permission.
    9.73 +
    9.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    9.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    9.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    9.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
    9.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    9.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    9.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    9.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    9.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    9.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    9.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    9.85 +*/
    9.86 +
    9.87 +package jdk.internal.dynalink;
    9.88 +
    9.89 +import java.lang.invoke.MutableCallSite;
    9.90 +import java.util.ArrayList;
    9.91 +import java.util.Arrays;
    9.92 +import java.util.Collections;
    9.93 +import java.util.HashSet;
    9.94 +import java.util.LinkedList;
    9.95 +import java.util.List;
    9.96 +import java.util.Set;
    9.97 +import jdk.internal.dynalink.beans.BeansLinker;
    9.98 +import jdk.internal.dynalink.linker.GuardingDynamicLinker;
    9.99 +import jdk.internal.dynalink.linker.GuardingTypeConverterFactory;
   9.100 +import jdk.internal.dynalink.linker.LinkRequest;
   9.101 +import jdk.internal.dynalink.support.AutoDiscovery;
   9.102 +import jdk.internal.dynalink.support.BottomGuardingDynamicLinker;
   9.103 +import jdk.internal.dynalink.support.CompositeGuardingDynamicLinker;
   9.104 +import jdk.internal.dynalink.support.CompositeTypeBasedGuardingDynamicLinker;
   9.105 +import jdk.internal.dynalink.support.LinkerServicesImpl;
   9.106 +import jdk.internal.dynalink.support.TypeConverterFactory;
   9.107 +
   9.108 +
   9.109 +/**
   9.110 + * A factory class for creating {@link DynamicLinker}s. The most usual dynamic linker is a linker that is a composition
   9.111 + * of all {@link GuardingDynamicLinker}s known and pre-created by the caller as well as any
   9.112 + * {@link AutoDiscovery automatically discovered} guarding linkers and the standard fallback {@link BeansLinker}. See
   9.113 + * {@link DynamicLinker} documentation for tips on how to use this class.
   9.114 + *
   9.115 + * @author Attila Szegedi
   9.116 + */
   9.117 +public class DynamicLinkerFactory {
   9.118 +
   9.119 +    /**
   9.120 +     * Default value for {@link #setUnstableRelinkThreshold(int) unstable relink threshold}.
   9.121 +     */
   9.122 +    public static final int DEFAULT_UNSTABLE_RELINK_THRESHOLD = 8;
   9.123 +
   9.124 +    private ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
   9.125 +    private List<? extends GuardingDynamicLinker> prioritizedLinkers;
   9.126 +    private List<? extends GuardingDynamicLinker> fallbackLinkers;
   9.127 +    private int runtimeContextArgCount = 0;
   9.128 +    private boolean syncOnRelink = false;
   9.129 +    private int unstableRelinkThreshold = DEFAULT_UNSTABLE_RELINK_THRESHOLD;
   9.130 +
   9.131 +    /**
   9.132 +     * Sets the class loader for automatic discovery of available linkers. If not set explicitly, then the thread
   9.133 +     * context class loader at the time of the constructor invocation will be used.
   9.134 +     *
   9.135 +     * @param classLoader the class loader used for the autodiscovery of available linkers.
   9.136 +     */
   9.137 +    public void setClassLoader(ClassLoader classLoader) {
   9.138 +        this.classLoader = classLoader;
   9.139 +    }
   9.140 +
   9.141 +    /**
   9.142 +     * Sets the prioritized linkers. Language runtimes using this framework will usually precreate at least the linker
   9.143 +     * for their own language. These linkers will be consulted first in the resulting dynamic linker, before any
   9.144 +     * autodiscovered linkers. If the framework also autodiscovers a linker of the same class as one of the prioritized
   9.145 +     * linkers, it will be ignored and the explicit prioritized instance will be used.
   9.146 +     *
   9.147 +     * @param prioritizedLinkers the list of prioritized linkers. Null can be passed to indicate no prioritized linkers
   9.148 +     * (this is also the default value).
   9.149 +     */
   9.150 +    public void setPrioritizedLinkers(List<? extends GuardingDynamicLinker> prioritizedLinkers) {
   9.151 +        this.prioritizedLinkers =
   9.152 +                prioritizedLinkers == null ? null : new ArrayList<>(prioritizedLinkers);
   9.153 +    }
   9.154 +
   9.155 +    /**
   9.156 +     * Sets the prioritized linkers. Language runtimes using this framework will usually precreate at least the linker
   9.157 +     * for their own language. These linkers will be consulted first in the resulting dynamic linker, before any
   9.158 +     * autodiscovered linkers. If the framework also autodiscovers a linker of the same class as one of the prioritized
   9.159 +     * linkers, it will be ignored and the explicit prioritized instance will be used.
   9.160 +     *
   9.161 +     * @param prioritizedLinkers a list of prioritized linkers.
   9.162 +     */
   9.163 +    public void setPrioritizedLinkers(GuardingDynamicLinker... prioritizedLinkers) {
   9.164 +        setPrioritizedLinkers(Arrays.asList(prioritizedLinkers));
   9.165 +    }
   9.166 +
   9.167 +    /**
   9.168 +     * Sets a single prioritized linker. Identical to calling {@link #setPrioritizedLinkers(List)} with a single-element
   9.169 +     * list.
   9.170 +     *
   9.171 +     * @param prioritizedLinker the single prioritized linker. Must not be null.
   9.172 +     * @throws IllegalArgumentException if null is passed.
   9.173 +     */
   9.174 +    public void setPrioritizedLinker(GuardingDynamicLinker prioritizedLinker) {
   9.175 +        if(prioritizedLinker == null) {
   9.176 +            throw new IllegalArgumentException("prioritizedLinker == null");
   9.177 +        }
   9.178 +        this.prioritizedLinkers = Collections.singletonList(prioritizedLinker);
   9.179 +    }
   9.180 +
   9.181 +    /**
   9.182 +     * Sets the fallback linkers. These linkers will be consulted last in the resulting composite linker, after any
   9.183 +     * autodiscovered linkers. If the framework also autodiscovers a linker of the same class as one of the fallback
   9.184 +     * linkers, it will be ignored and the explicit fallback instance will be used.
   9.185 +     *
   9.186 +     * @param fallbackLinkers the list of fallback linkers. Can be empty to indicate the caller wishes to set no
   9.187 +     * fallback linkers.
   9.188 +     */
   9.189 +    public void setFallbackLinkers(List<? extends GuardingDynamicLinker> fallbackLinkers) {
   9.190 +        this.fallbackLinkers = fallbackLinkers == null ? null : new ArrayList<>(fallbackLinkers);
   9.191 +    }
   9.192 +
   9.193 +    /**
   9.194 +     * Sets the fallback linkers. These linkers will be consulted last in the resulting composite linker, after any
   9.195 +     * autodiscovered linkers. If the framework also autodiscovers a linker of the same class as one of the fallback
   9.196 +     * linkers, it will be ignored and the explicit fallback instance will be used.
   9.197 +     *
   9.198 +     * @param fallbackLinkers the list of fallback linkers. Can be empty to indicate the caller wishes to set no
   9.199 +     * fallback linkers. If it is left as null, the standard fallback {@link BeansLinker} will be used.
   9.200 +     */
   9.201 +    public void setFallbackLinkers(GuardingDynamicLinker... fallbackLinkers) {
   9.202 +        setFallbackLinkers(Arrays.asList(fallbackLinkers));
   9.203 +    }
   9.204 +
   9.205 +    /**
   9.206 +     * Sets the number of arguments in the call sites that represent the stack context of the language runtime creating
   9.207 +     * the linker. If the language runtime uses no context information passed on stack, then it should be zero
   9.208 +     * (the default value). If it is set to nonzero value, then every dynamic call site emitted by this runtime must
   9.209 +     * have the argument list of the form: {@code (this, contextArg1[, contextArg2[, ...]], normalArgs)}. It is
   9.210 +     * advisable to only pass one context-specific argument, though, of an easily recognizable, runtime specific type
   9.211 +     * encapsulating the runtime thread local state.
   9.212 +     *
   9.213 +     * @param runtimeContextArgCount the number of language runtime context arguments in call sites.
   9.214 +     */
   9.215 +    public void setRuntimeContextArgCount(int runtimeContextArgCount) {
   9.216 +        if(runtimeContextArgCount < 0) {
   9.217 +            throw new IllegalArgumentException("runtimeContextArgCount < 0");
   9.218 +        }
   9.219 +        this.runtimeContextArgCount = runtimeContextArgCount;
   9.220 +    }
   9.221 +
   9.222 +    /**
   9.223 +     * Sets whether the linker created by this factory will invoke {@link MutableCallSite#syncAll(MutableCallSite[])}
   9.224 +     * after a call site is relinked. Defaults to false. You probably want to set it to true if your runtime supports
   9.225 +     * multithreaded execution of dynamically linked code.
   9.226 +     * @param syncOnRelink true for invoking sync on relink, false otherwise.
   9.227 +     */
   9.228 +    public void setSyncOnRelink(boolean syncOnRelink) {
   9.229 +        this.syncOnRelink = syncOnRelink;
   9.230 +    }
   9.231 +
   9.232 +    /**
   9.233 +     * Sets the unstable relink threshold; the number of times a call site is relinked after which it will be
   9.234 +     * considered unstable, and subsequent link requests for it will indicate this.
   9.235 +     * @param unstableRelinkThreshold the new threshold. Must not be less than zero. The value of zero means that
   9.236 +     * call sites will never be considered unstable.
   9.237 +     * @see LinkRequest#isCallSiteUnstable()
   9.238 +     */
   9.239 +    public void setUnstableRelinkThreshold(int unstableRelinkThreshold) {
   9.240 +        if(unstableRelinkThreshold < 0) {
   9.241 +            throw new IllegalArgumentException("unstableRelinkThreshold < 0");
   9.242 +        }
   9.243 +        this.unstableRelinkThreshold = unstableRelinkThreshold;
   9.244 +    }
   9.245 +
   9.246 +    /**
   9.247 +     * Creates a new dynamic linker consisting of all the prioritized, autodiscovered, and fallback linkers.
   9.248 +     *
   9.249 +     * @return the new dynamic Linker
   9.250 +     */
   9.251 +    public DynamicLinker createLinker() {
   9.252 +        // Treat nulls appropriately
   9.253 +        if(prioritizedLinkers == null) {
   9.254 +            prioritizedLinkers = Collections.emptyList();
   9.255 +        }
   9.256 +        if(fallbackLinkers == null) {
   9.257 +            fallbackLinkers = Collections.singletonList(new BeansLinker());
   9.258 +        }
   9.259 +
   9.260 +        // Gather classes of all precreated (prioritized and fallback) linkers.
   9.261 +        // We'll filter out any discovered linkers of the same class.
   9.262 +        final Set<Class<? extends GuardingDynamicLinker>> knownLinkerClasses = new HashSet<>();
   9.263 +        addClasses(knownLinkerClasses, prioritizedLinkers);
   9.264 +        addClasses(knownLinkerClasses, fallbackLinkers);
   9.265 +
   9.266 +        final List<GuardingDynamicLinker> discovered = AutoDiscovery.loadLinkers(classLoader);
   9.267 +        // Now, concatenate ...
   9.268 +        final List<GuardingDynamicLinker> linkers = new ArrayList<>(prioritizedLinkers.size() + discovered.size()
   9.269 +                + fallbackLinkers.size());
   9.270 +        // ... prioritized linkers, ...
   9.271 +        linkers.addAll(prioritizedLinkers);
   9.272 +        // ... filtered discovered linkers, ...
   9.273 +        for(GuardingDynamicLinker linker: discovered) {
   9.274 +            if(!knownLinkerClasses.contains(linker.getClass())) {
   9.275 +                linkers.add(linker);
   9.276 +            }
   9.277 +        }
   9.278 +        // ... and finally fallback linkers.
   9.279 +        linkers.addAll(fallbackLinkers);
   9.280 +        final List<GuardingDynamicLinker> optimized = CompositeTypeBasedGuardingDynamicLinker.optimize(linkers);
   9.281 +        final GuardingDynamicLinker composite;
   9.282 +        switch(linkers.size()) {
   9.283 +            case 0: {
   9.284 +                composite = BottomGuardingDynamicLinker.INSTANCE;
   9.285 +                break;
   9.286 +            }
   9.287 +            case 1: {
   9.288 +                composite = optimized.get(0);
   9.289 +                break;
   9.290 +            }
   9.291 +            default: {
   9.292 +                composite = new CompositeGuardingDynamicLinker(optimized);
   9.293 +                break;
   9.294 +            }
   9.295 +        }
   9.296 +
   9.297 +        final List<GuardingTypeConverterFactory> typeConverters = new LinkedList<>();
   9.298 +        for(GuardingDynamicLinker linker: linkers) {
   9.299 +            if(linker instanceof GuardingTypeConverterFactory) {
   9.300 +                typeConverters.add((GuardingTypeConverterFactory)linker);
   9.301 +            }
   9.302 +        }
   9.303 +
   9.304 +        return new DynamicLinker(new LinkerServicesImpl(new TypeConverterFactory(typeConverters), composite),
   9.305 +                runtimeContextArgCount, syncOnRelink, unstableRelinkThreshold);
   9.306 +    }
   9.307 +
   9.308 +    private static void addClasses(Set<Class<? extends GuardingDynamicLinker>> knownLinkerClasses,
   9.309 +            List<? extends GuardingDynamicLinker> linkers) {
   9.310 +        for(GuardingDynamicLinker linker: linkers) {
   9.311 +            knownLinkerClasses.add(linker.getClass());
   9.312 +        }
   9.313 +    }
   9.314 +}
   9.315 \ No newline at end of file

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/src/jdk/internal/dynalink/MonomorphicCallSite.java	Thu Feb 14 13:22:26 2013 +0100
    10.3 @@ -0,0 +1,116 @@
    10.4 +/*
    10.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    10.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    10.7 + *
    10.8 + * This code is free software; you can redistribute it and/or modify it
    10.9 + * under the terms of the GNU General Public License version 2 only, as
   10.10 + * published by the Free Software Foundation.  Oracle designates this
   10.11 + * particular file as subject to the "Classpath" exception as provided
   10.12 + * by Oracle in the LICENSE file that accompanied this code.
   10.13 + *
   10.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   10.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   10.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   10.17 + * version 2 for more details (a copy is included in the LICENSE file that
   10.18 + * accompanied this code).
   10.19 + *
   10.20 + * You should have received a copy of the GNU General Public License version
   10.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   10.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   10.23 + *
   10.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   10.25 + * or visit www.oracle.com if you need additional information or have any
   10.26 + * questions.
   10.27 + */
   10.28 +
   10.29 +/*
   10.30 + * This file is available under and governed by the GNU General Public
   10.31 + * License version 2 only, as published by the Free Software Foundation.
   10.32 + * However, the following notice accompanied the original version of this
   10.33 + * file, and Oracle licenses the original version of this file under the BSD
   10.34 + * license:
   10.35 + */
   10.36 +/*
   10.37 +   Copyright 2009-2013 Attila Szegedi
   10.38 +
   10.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   10.40 +   and the BSD License (the "BSD License"), with licensee being free to
   10.41 +   choose either of the two at their discretion.
   10.42 +
   10.43 +   You may not use this file except in compliance with either the Apache
   10.44 +   License or the BSD License.
   10.45 +
   10.46 +   If you choose to use this file in compliance with the Apache License, the
   10.47 +   following notice applies to you:
   10.48 +
   10.49 +       You may obtain a copy of the Apache License at
   10.50 +
   10.51 +           http://www.apache.org/licenses/LICENSE-2.0
   10.52 +
   10.53 +       Unless required by applicable law or agreed to in writing, software
   10.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   10.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   10.56 +       implied. See the License for the specific language governing
   10.57 +       permissions and limitations under the License.
   10.58 +
   10.59 +   If you choose to use this file in compliance with the BSD License, the
   10.60 +   following notice applies to you:
   10.61 +
   10.62 +       Redistribution and use in source and binary forms, with or without
   10.63 +       modification, are permitted provided that the following conditions are
   10.64 +       met:
   10.65 +       * Redistributions of source code must retain the above copyright
   10.66 +         notice, this list of conditions and the following disclaimer.
   10.67 +       * Redistributions in binary form must reproduce the above copyright
   10.68 +         notice, this list of conditions and the following disclaimer in the
   10.69 +         documentation and/or other materials provided with the distribution.
   10.70 +       * Neither the name of the copyright holder nor the names of
   10.71 +         contributors may be used to endorse or promote products derived from
   10.72 +         this software without specific prior written permission.
   10.73 +
   10.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   10.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   10.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   10.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   10.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   10.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   10.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   10.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   10.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   10.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   10.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   10.85 +*/
   10.86 +
   10.87 +package jdk.internal.dynalink;
   10.88 +
   10.89 +import java.lang.invoke.MethodHandle;
   10.90 +import jdk.internal.dynalink.linker.GuardedInvocation;
   10.91 +import jdk.internal.dynalink.support.AbstractRelinkableCallSite;
   10.92 +
   10.93 +
   10.94 +/**
   10.95 + * A relinkable call site that implements monomorphic inline caching strategy. After it linked a method, it will keep it
   10.96 + * until either its guard evaluates to false, or its switchpoint is invalidated, at which time it will throw away the
   10.97 + * previous linkage, and trigger relinking with its associated {@link DynamicLinker}.
   10.98 + *
   10.99 + * @author Attila Szegedi
  10.100 + */
  10.101 +public class MonomorphicCallSite extends AbstractRelinkableCallSite {
  10.102 +    /**
  10.103 +     * Creates a new call site with monomorphic inline caching strategy.
  10.104 +     * @param descriptor the descriptor for this call site
  10.105 +     */
  10.106 +    public MonomorphicCallSite(CallSiteDescriptor descriptor) {
  10.107 +        super(descriptor);
  10.108 +    }
  10.109 +
  10.110 +    @Override
  10.111 +    public void relink(GuardedInvocation guardedInvocation, MethodHandle relink) {
  10.112 +        setTarget(guardedInvocation.compose(relink));
  10.113 +    }
  10.114 +
  10.115 +    @Override
  10.116 +    public void resetAndRelink(GuardedInvocation guardedInvocation, MethodHandle relink) {
  10.117 +        relink(guardedInvocation, relink);
  10.118 +    }
  10.119 +}
  10.120 \ No newline at end of file

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/src/jdk/internal/dynalink/NoSuchDynamicMethodException.java	Thu Feb 14 13:22:26 2013 +0100
    11.3 @@ -0,0 +1,103 @@
    11.4 +/*
    11.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    11.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    11.7 + *
    11.8 + * This code is free software; you can redistribute it and/or modify it
    11.9 + * under the terms of the GNU General Public License version 2 only, as
   11.10 + * published by the Free Software Foundation.  Oracle designates this
   11.11 + * particular file as subject to the "Classpath" exception as provided
   11.12 + * by Oracle in the LICENSE file that accompanied this code.
   11.13 + *
   11.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   11.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   11.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   11.17 + * version 2 for more details (a copy is included in the LICENSE file that
   11.18 + * accompanied this code).
   11.19 + *
   11.20 + * You should have received a copy of the GNU General Public License version
   11.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   11.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   11.23 + *
   11.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   11.25 + * or visit www.oracle.com if you need additional information or have any
   11.26 + * questions.
   11.27 + */
   11.28 +
   11.29 +/*
   11.30 + * This file is available under and governed by the GNU General Public
   11.31 + * License version 2 only, as published by the Free Software Foundation.
   11.32 + * However, the following notice accompanied the original version of this
   11.33 + * file, and Oracle licenses the original version of this file under the BSD
   11.34 + * license:
   11.35 + */
   11.36 +/*
   11.37 +   Copyright 2009-2013 Attila Szegedi
   11.38 +
   11.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   11.40 +   and the BSD License (the "BSD License"), with licensee being free to
   11.41 +   choose either of the two at their discretion.
   11.42 +
   11.43 +   You may not use this file except in compliance with either the Apache
   11.44 +   License or the BSD License.
   11.45 +
   11.46 +   If you choose to use this file in compliance with the Apache License, the
   11.47 +   following notice applies to you:
   11.48 +
   11.49 +       You may obtain a copy of the Apache License at
   11.50 +
   11.51 +           http://www.apache.org/licenses/LICENSE-2.0
   11.52 +
   11.53 +       Unless required by applicable law or agreed to in writing, software
   11.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   11.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   11.56 +       implied. See the License for the specific language governing
   11.57 +       permissions and limitations under the License.
   11.58 +
   11.59 +   If you choose to use this file in compliance with the BSD License, the
   11.60 +   following notice applies to you:
   11.61 +
   11.62 +       Redistribution and use in source and binary forms, with or without
   11.63 +       modification, are permitted provided that the following conditions are
   11.64 +       met:
   11.65 +       * Redistributions of source code must retain the above copyright
   11.66 +         notice, this list of conditions and the following disclaimer.
   11.67 +       * Redistributions in binary form must reproduce the above copyright
   11.68 +         notice, this list of conditions and the following disclaimer in the
   11.69 +         documentation and/or other materials provided with the distribution.
   11.70 +       * Neither the name of the copyright holder nor the names of
   11.71 +         contributors may be used to endorse or promote products derived from
   11.72 +         this software without specific prior written permission.
   11.73 +
   11.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   11.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   11.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   11.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   11.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   11.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   11.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   11.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   11.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   11.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   11.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   11.85 +*/
   11.86 +
   11.87 +package jdk.internal.dynalink;
   11.88 +
   11.89 +import jdk.internal.dynalink.linker.GuardingDynamicLinker;
   11.90 +
   11.91 +/**
   11.92 + * Thrown at the invocation if the call site can not be linked by any available {@link GuardingDynamicLinker}.
   11.93 + *
   11.94 + * @author Attila Szegedi
   11.95 + */
   11.96 +public class NoSuchDynamicMethodException extends RuntimeException {
   11.97 +    private static final long serialVersionUID = 1L;
   11.98 +
   11.99 +    /**
  11.100 +     * Creates a new NoSuchDynamicMethodException
  11.101 +     * @param message the message of the exception.
  11.102 +     */
  11.103 +    public NoSuchDynamicMethodException(String message) {
  11.104 +        super(message);
  11.105 +    }
  11.106 +}
  11.107 \ No newline at end of file

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/src/jdk/internal/dynalink/RelinkableCallSite.java	Thu Feb 14 13:22:26 2013 +0100
    12.3 @@ -0,0 +1,148 @@
    12.4 +/*
    12.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    12.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    12.7 + *
    12.8 + * This code is free software; you can redistribute it and/or modify it
    12.9 + * under the terms of the GNU General Public License version 2 only, as
   12.10 + * published by the Free Software Foundation.  Oracle designates this
   12.11 + * particular file as subject to the "Classpath" exception as provided
   12.12 + * by Oracle in the LICENSE file that accompanied this code.
   12.13 + *
   12.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   12.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   12.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   12.17 + * version 2 for more details (a copy is included in the LICENSE file that
   12.18 + * accompanied this code).
   12.19 + *
   12.20 + * You should have received a copy of the GNU General Public License version
   12.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   12.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   12.23 + *
   12.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   12.25 + * or visit www.oracle.com if you need additional information or have any
   12.26 + * questions.
   12.27 + */
   12.28 +
   12.29 +/*
   12.30 + * This file is available under and governed by the GNU General Public
   12.31 + * License version 2 only, as published by the Free Software Foundation.
   12.32 + * However, the following notice accompanied the original version of this
   12.33 + * file, and Oracle licenses the original version of this file under the BSD
   12.34 + * license:
   12.35 + */
   12.36 +/*
   12.37 +   Copyright 2009-2013 Attila Szegedi
   12.38 +
   12.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   12.40 +   and the BSD License (the "BSD License"), with licensee being free to
   12.41 +   choose either of the two at their discretion.
   12.42 +
   12.43 +   You may not use this file except in compliance with either the Apache
   12.44 +   License or the BSD License.
   12.45 +
   12.46 +   If you choose to use this file in compliance with the Apache License, the
   12.47 +   following notice applies to you:
   12.48 +
   12.49 +       You may obtain a copy of the Apache License at
   12.50 +
   12.51 +           http://www.apache.org/licenses/LICENSE-2.0
   12.52 +
   12.53 +       Unless required by applicable law or agreed to in writing, software
   12.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   12.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   12.56 +       implied. See the License for the specific language governing
   12.57 +       permissions and limitations under the License.
   12.58 +
   12.59 +   If you choose to use this file in compliance with the BSD License, the
   12.60 +   following notice applies to you:
   12.61 +
   12.62 +       Redistribution and use in source and binary forms, with or without
   12.63 +       modification, are permitted provided that the following conditions are
   12.64 +       met:
   12.65 +       * Redistributions of source code must retain the above copyright
   12.66 +         notice, this list of conditions and the following disclaimer.
   12.67 +       * Redistributions in binary form must reproduce the above copyright
   12.68 +         notice, this list of conditions and the following disclaimer in the
   12.69 +         documentation and/or other materials provided with the distribution.
   12.70 +       * Neither the name of the copyright holder nor the names of
   12.71 +         contributors may be used to endorse or promote products derived from
   12.72 +         this software without specific prior written permission.
   12.73 +
   12.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   12.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   12.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   12.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   12.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   12.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   12.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   12.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   12.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   12.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   12.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   12.85 +*/
   12.86 +
   12.87 +package jdk.internal.dynalink;
   12.88 +
   12.89 +import java.lang.invoke.CallSite;
   12.90 +import java.lang.invoke.MethodHandle;
   12.91 +import java.lang.invoke.MutableCallSite;
   12.92 +import java.lang.invoke.VolatileCallSite;
   12.93 +import jdk.internal.dynalink.linker.GuardedInvocation;
   12.94 +
   12.95 +
   12.96 +/**
   12.97 + * Interface for relinkable call sites. Language runtimes wishing to use this framework must use subclasses of
   12.98 + * {@link CallSite} that also implement this interface as their call sites. There is a readily usable
   12.99 + * {@link MonomorphicCallSite} subclass that implements monomorphic inline caching strategy as well as a
  12.100 + * {@link ChainedCallSite} that retains a chain of already linked method handles. The reason this is defined as an
  12.101 + * interface instead of a concrete, albeit abstract class is that it allows independent implementations to choose
  12.102 + * between {@link MutableCallSite} and {@link VolatileCallSite} as they see fit.
  12.103 + *
  12.104 + * @author Attila Szegedi
  12.105 + */
  12.106 +public interface RelinkableCallSite {
  12.107 +    /**
  12.108 +     * Initializes the relinkable call site by setting a relink-and-invoke method handle. The call site implementation
  12.109 +     * is supposed to set this method handle as its target.
  12.110 +     * @param relinkAndInvoke a relink-and-invoke method handle supplied by the {@link DynamicLinker}.
  12.111 +     */
  12.112 +    public void initialize(MethodHandle relinkAndInvoke);
  12.113 +
  12.114 +    /**
  12.115 +     * Returns the descriptor for this call site.
  12.116 +     *
  12.117 +     * @return the descriptor for this call site.
  12.118 +     */
  12.119 +    public CallSiteDescriptor getDescriptor();
  12.120 +
  12.121 +    /**
  12.122 +     * This method will be called by the dynamic linker every time the call site is normally relinked. It will be passed
  12.123 +     * a {@code GuardedInvocation} that the call site should incorporate into its target method handle. When this method
  12.124 +     * is called, the call site is allowed to keep other non-invalidated invocations around for implementation of
  12.125 +     * polymorphic inline caches and compose them with this invocation to form its final target.
  12.126 +     *
  12.127 +     * @param guardedInvocation the guarded invocation that the call site should incorporate into its target method
  12.128 +     * handle.
  12.129 +     * @param fallback the fallback method. This is a method matching the method type of the call site that is supplied
  12.130 +     * by the {@link DynamicLinker} to be used by this call site as a fallback when it can't invoke its target with the
  12.131 +     * passed arguments. The fallback method is such that when it's invoked, it'll try to discover the adequate target
  12.132 +     * for the invocation, subsequently invoke {@link #relink(GuardedInvocation, MethodHandle)} or
  12.133 +     * {@link #resetAndRelink(GuardedInvocation, MethodHandle)}, and finally invoke the target.
  12.134 +     */
  12.135 +    public void relink(GuardedInvocation guardedInvocation, MethodHandle fallback);
  12.136 +
  12.137 +    /**
  12.138 +     * This method will be called by the dynamic linker every time the call site is relinked and the linker wishes the
  12.139 +     * call site to throw away any prior linkage state. It will be passed a {@code GuardedInvocation} that the call site
  12.140 +     * should use to build its target method handle. When this method is called, the call site is discouraged from
  12.141 +     * keeping previous state around, and is supposed to only link the current invocation.
  12.142 +     *
  12.143 +     * @param guardedInvocation the guarded invocation that the call site should use to build its target method handle.
  12.144 +     * @param fallback the fallback method. This is a method matching the method type of the call site that is supplied
  12.145 +     * by the {@link DynamicLinker} to be used by this call site as a fallback when it can't invoke its target with the
  12.146 +     * passed arguments. The fallback method is such that when it's invoked, it'll try to discover the adequate target
  12.147 +     * for the invocation, subsequently invoke {@link #relink(GuardedInvocation, MethodHandle)} or
  12.148 +     * {@link #resetAndRelink(GuardedInvocation, MethodHandle)}, and finally invoke the target.
  12.149 +     */
  12.150 +    public void resetAndRelink(GuardedInvocation guardedInvocation, MethodHandle fallback);
  12.151 +}
  12.152 \ No newline at end of file

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/src/jdk/internal/dynalink/beans/AbstractJavaLinker.java	Thu Feb 14 13:22:26 2013 +0100
    13.3 @@ -0,0 +1,690 @@
    13.4 +/*
    13.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    13.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.7 + *
    13.8 + * This code is free software; you can redistribute it and/or modify it
    13.9 + * under the terms of the GNU General Public License version 2 only, as
   13.10 + * published by the Free Software Foundation.  Oracle designates this
   13.11 + * particular file as subject to the "Classpath" exception as provided
   13.12 + * by Oracle in the LICENSE file that accompanied this code.
   13.13 + *
   13.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   13.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13.17 + * version 2 for more details (a copy is included in the LICENSE file that
   13.18 + * accompanied this code).
   13.19 + *
   13.20 + * You should have received a copy of the GNU General Public License version
   13.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   13.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   13.23 + *
   13.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   13.25 + * or visit www.oracle.com if you need additional information or have any
   13.26 + * questions.
   13.27 + */
   13.28 +
   13.29 +/*
   13.30 + * This file is available under and governed by the GNU General Public
   13.31 + * License version 2 only, as published by the Free Software Foundation.
   13.32 + * However, the following notice accompanied the original version of this
   13.33 + * file, and Oracle licenses the original version of this file under the BSD
   13.34 + * license:
   13.35 + */
   13.36 +/*
   13.37 +   Copyright 2009-2013 Attila Szegedi
   13.38 +
   13.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   13.40 +   and the BSD License (the "BSD License"), with licensee being free to
   13.41 +   choose either of the two at their discretion.
   13.42 +
   13.43 +   You may not use this file except in compliance with either the Apache
   13.44 +   License or the BSD License.
   13.45 +
   13.46 +   If you choose to use this file in compliance with the Apache License, the
   13.47 +   following notice applies to you:
   13.48 +
   13.49 +       You may obtain a copy of the Apache License at
   13.50 +
   13.51 +           http://www.apache.org/licenses/LICENSE-2.0
   13.52 +
   13.53 +       Unless required by applicable law or agreed to in writing, software
   13.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   13.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   13.56 +       implied. See the License for the specific language governing
   13.57 +       permissions and limitations under the License.
   13.58 +
   13.59 +   If you choose to use this file in compliance with the BSD License, the
   13.60 +   following notice applies to you:
   13.61 +
   13.62 +       Redistribution and use in source and binary forms, with or without
   13.63 +       modification, are permitted provided that the following conditions are
   13.64 +       met:
   13.65 +       * Redistributions of source code must retain the above copyright
   13.66 +         notice, this list of conditions and the following disclaimer.
   13.67 +       * Redistributions in binary form must reproduce the above copyright
   13.68 +         notice, this list of conditions and the following disclaimer in the
   13.69 +         documentation and/or other materials provided with the distribution.
   13.70 +       * Neither the name of the copyright holder nor the names of
   13.71 +         contributors may be used to endorse or promote products derived from
   13.72 +         this software without specific prior written permission.
   13.73 +
   13.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   13.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   13.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   13.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   13.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   13.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   13.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   13.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   13.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   13.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   13.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   13.85 +*/
   13.86 +
   13.87 +package jdk.internal.dynalink.beans;
   13.88 +
   13.89 +import java.beans.Introspector;
   13.90 +import java.lang.invoke.MethodHandle;
   13.91 +import java.lang.invoke.MethodHandles;
   13.92 +import java.lang.invoke.MethodType;
   13.93 +import java.lang.reflect.Field;
   13.94 +import java.lang.reflect.Method;
   13.95 +import java.lang.reflect.Modifier;
   13.96 +import java.util.HashMap;
   13.97 +import java.util.List;
   13.98 +import java.util.Map;
   13.99 +import jdk.internal.dynalink.CallSiteDescriptor;
  13.100 +import jdk.internal.dynalink.beans.GuardedInvocationComponent.ValidationType;
  13.101 +import jdk.internal.dynalink.linker.GuardedInvocation;
  13.102 +import jdk.internal.dynalink.linker.GuardingDynamicLinker;
  13.103 +import jdk.internal.dynalink.linker.LinkRequest;
  13.104 +import jdk.internal.dynalink.linker.LinkerServices;
  13.105 +import jdk.internal.dynalink.support.CallSiteDescriptorFactory;
  13.106 +import jdk.internal.dynalink.support.Guards;
  13.107 +import jdk.internal.dynalink.support.Lookup;
  13.108 +
  13.109 +
  13.110 +/**
  13.111 + * A base class for both {@link StaticClassLinker} and {@link BeanLinker}. Deals with common aspects of property
  13.112 + * exposure and method calls for both static and instance facets of a class.
  13.113 + *
  13.114 + * @author Attila Szegedi
  13.115 + */
  13.116 +abstract class AbstractJavaLinker implements GuardingDynamicLinker {
  13.117 +    final Class<?> clazz;
  13.118 +    private final MethodHandle classGuard;
  13.119 +    private final MethodHandle assignableGuard;
  13.120 +    private final Map<String, AnnotatedMethodHandle> propertyGetters = new HashMap<>();
  13.121 +    private final Map<String, DynamicMethod> propertySetters = new HashMap<>();
  13.122 +    private final Map<String, DynamicMethod> methods = new HashMap<>();
  13.123 +
  13.124 +    AbstractJavaLinker(Class<?> clazz, MethodHandle classGuard) {
  13.125 +        this(clazz, classGuard, classGuard);
  13.126 +    }
  13.127 +
  13.128 +    AbstractJavaLinker(Class<?> clazz, MethodHandle classGuard, MethodHandle assignableGuard) {
  13.129 +        this.clazz = clazz;
  13.130 +        this.classGuard = classGuard;
  13.131 +        this.assignableGuard = assignableGuard;
  13.132 +
  13.133 +        final FacetIntrospector introspector = createFacetIntrospector();
  13.134 +        try {
  13.135 +            // Add methods and properties
  13.136 +            for(Method method: introspector.getMethods()) {
  13.137 +                final String name = method.getName();
  13.138 +                final MethodHandle methodHandle = introspector.unreflect(method);
  13.139 +                // Add method
  13.140 +                addMember(name, methodHandle, methods);
  13.141 +                // Add the method as a property getter and/or setter
  13.142 +                if(name.startsWith("get") && name.length() > 3 && method.getParameterTypes().length == 0) {
  13.143 +                    // Property getter
  13.144 +                    setPropertyGetter(Introspector.decapitalize(name.substring(3)), introspector.unreflect(
  13.145 +                            getMostGenericGetter(method)), ValidationType.INSTANCE_OF);
  13.146 +                } else if(name.startsWith("is") && name.length() > 2 && method.getParameterTypes().length == 0 &&
  13.147 +                        method.getReturnType() == boolean.class) {
  13.148 +                    // Boolean property getter
  13.149 +                    setPropertyGetter(Introspector.decapitalize(name.substring(2)), introspector.unreflect(
  13.150 +                            getMostGenericGetter(method)), ValidationType.INSTANCE_OF);
  13.151 +                } else if(name.startsWith("set") && name.length() > 3 && method.getParameterTypes().length == 1) {
  13.152 +                    // Property setter
  13.153 +                    addMember(Introspector.decapitalize(name.substring(3)), methodHandle, propertySetters);
  13.154 +                }
  13.155 +            }
  13.156 +
  13.157 +            // Add field getter/setters as property getters/setters.
  13.158 +            for(Field field: introspector.getFields()) {
  13.159 +                final String name = field.getName();
  13.160 +                // Only add a property getter when one is not defined already as a getXxx()/isXxx() method.
  13.161 +                if(!propertyGetters.containsKey(name)) {
  13.162 +                    setPropertyGetter(name, introspector.unreflectGetter(field), ValidationType.EXACT_CLASS);
  13.163 +                }
  13.164 +                if(!(Modifier.isFinal(field.getModifiers()) || propertySetters.containsKey(name))) {
  13.165 +                    addMember(name, introspector.unreflectSetter(field), propertySetters);
  13.166 +                }
  13.167 +            }
  13.168 +
  13.169 +            // Add inner classes, but only those for which we don't hide a property with it
  13.170 +            for(Map.Entry<String, MethodHandle> innerClassSpec: introspector.getInnerClassGetters().entrySet()) {
  13.171 +                final String name = innerClassSpec.getKey();
  13.172 +                if(!propertyGetters.containsKey(name)) {
  13.173 +                    setPropertyGetter(name, innerClassSpec.getValue(), ValidationType.EXACT_CLASS);
  13.174 +                }
  13.175 +            }
  13.176 +        } finally {
  13.177 +            introspector.close();
  13.178 +        }
  13.179 +    }
  13.180 +
  13.181 +    abstract FacetIntrospector createFacetIntrospector();
  13.182 +
  13.183 +    void setPropertyGetter(String name, MethodHandle handle, ValidationType validationType) {
  13.184 +        propertyGetters.put(name, new AnnotatedMethodHandle(handle, validationType));
  13.185 +    }
  13.186 +
  13.187 +    private void addMember(String name, MethodHandle mh, Map<String, DynamicMethod> methodMap) {
  13.188 +        final DynamicMethod existingMethod = methodMap.get(name);
  13.189 +        final DynamicMethod newMethod = addMember(mh, existingMethod, clazz, name);
  13.190 +        if(newMethod != existingMethod) {
  13.191 +            methodMap.put(name, newMethod);
  13.192 +        }
  13.193 +    }
  13.194 +
  13.195 +    static DynamicMethod createDynamicMethod(Iterable<MethodHandle> methodHandles, Class<?> clazz, String name) {
  13.196 +        DynamicMethod dynMethod = null;
  13.197 +        for(MethodHandle methodHandle: methodHandles) {
  13.198 +            dynMethod = addMember(methodHandle, dynMethod, clazz, name);
  13.199 +        }
  13.200 +        return dynMethod;
  13.201 +    }
  13.202 +
  13.203 +    private static DynamicMethod addMember(MethodHandle mh, DynamicMethod existing, Class<?> clazz, String name) {
  13.204 +        if(existing == null) {
  13.205 +            return new SimpleDynamicMethod(mh, clazz, name);
  13.206 +        } else if(existing.contains(mh)) {
  13.207 +            return existing;
  13.208 +        } else if(existing instanceof SimpleDynamicMethod) {
  13.209 +            final OverloadedDynamicMethod odm = new OverloadedDynamicMethod(clazz, name);
  13.210 +            odm.addMethod(((SimpleDynamicMethod)existing));
  13.211 +            odm.addMethod(mh);
  13.212 +            return odm;
  13.213 +        } else if(existing instanceof OverloadedDynamicMethod) {
  13.214 +            ((OverloadedDynamicMethod)existing).addMethod(mh);
  13.215 +            return existing;
  13.216 +        }
  13.217 +        throw new AssertionError();
  13.218 +    }
  13.219 +
  13.220 +    @Override
  13.221 +    public GuardedInvocation getGuardedInvocation(LinkRequest request, final LinkerServices linkerServices)
  13.222 +            throws Exception {
  13.223 +        final LinkRequest ncrequest = request.withoutRuntimeContext();
  13.224 +        // BeansLinker already checked that the name is at least 2 elements long and the first element is "dyn".
  13.225 +        final CallSiteDescriptor callSiteDescriptor = ncrequest.getCallSiteDescriptor();
  13.226 +        final String op = callSiteDescriptor.getNameToken(CallSiteDescriptor.OPERATOR);
  13.227 +        // Either dyn:callMethod:name(this[,args]) or dyn:callMethod(this,name[,args]).
  13.228 +        if("callMethod" == op) {
  13.229 +            return getCallPropWithThis(callSiteDescriptor, linkerServices);
  13.230 +        }
  13.231 +        List<String> operations = CallSiteDescriptorFactory.tokenizeOperators(callSiteDescriptor);
  13.232 +        while(!operations.isEmpty()) {
  13.233 +            final GuardedInvocationComponent gic = getGuardedInvocationComponent(callSiteDescriptor, linkerServices,
  13.234 +                    operations);
  13.235 +            if(gic != null) {
  13.236 +                return gic.getGuardedInvocation();
  13.237 +            }
  13.238 +            operations = pop(operations);
  13.239 +        }
  13.240 +        return null;
  13.241 +    }
  13.242 +
  13.243 +    protected GuardedInvocationComponent getGuardedInvocationComponent(CallSiteDescriptor callSiteDescriptor,
  13.244 +            LinkerServices linkerServices, List<String> operations) throws Exception {
  13.245 +        if(operations.isEmpty()) {
  13.246 +            return null;
  13.247 +        }
  13.248 +        final String op = operations.get(0);
  13.249 +        // Either dyn:getProp:name(this) or dyn:getProp(this, name)
  13.250 +        if("getProp".equals(op)) {
  13.251 +            return getPropertyGetter(callSiteDescriptor, linkerServices, pop(operations));
  13.252 +        }
  13.253 +        // Either dyn:setProp:name(this, value) or dyn:setProp(this, name, value)
  13.254 +        if("setProp".equals(op)) {
  13.255 +            return getPropertySetter(callSiteDescriptor, linkerServices, pop(operations));
  13.256 +        }
  13.257 +        // Either dyn:getMethod:name(this), or dyn:getMethod(this, name)
  13.258 +        if("getMethod".equals(op)) {
  13.259 +            return getMethodGetter(callSiteDescriptor, linkerServices, pop(operations));
  13.260 +        }
  13.261 +        return null;
  13.262 +    }
  13.263 +
  13.264 +    static final <T> List<T> pop(List<T> l) {
  13.265 +        return l.subList(1, l.size());
  13.266 +    }
  13.267 +
  13.268 +    MethodHandle getClassGuard(CallSiteDescriptor desc) {
  13.269 +        return getClassGuard(desc.getMethodType());
  13.270 +    }
  13.271 +
  13.272 +    MethodHandle getClassGuard(MethodType type) {
  13.273 +        return Guards.asType(classGuard, type);
  13.274 +    }
  13.275 +
  13.276 +    GuardedInvocationComponent getClassGuardedInvocationComponent(MethodHandle invocation, MethodType type) {
  13.277 +        return new GuardedInvocationComponent(invocation, getClassGuard(type), clazz, ValidationType.EXACT_CLASS);
  13.278 +    }
  13.279 +
  13.280 +    private MethodHandle getAssignableGuard(MethodType type) {
  13.281 +        return Guards.asType(assignableGuard, type);
  13.282 +    }
  13.283 +
  13.284 +    private GuardedInvocation getCallPropWithThis(CallSiteDescriptor callSiteDescriptor, LinkerServices linkerServices) {
  13.285 +        switch(callSiteDescriptor.getNameTokenCount()) {
  13.286 +            case 3: {
  13.287 +                return createGuardedDynamicMethodInvocation(callSiteDescriptor.getMethodType(), linkerServices,
  13.288 +                        callSiteDescriptor.getNameToken(CallSiteDescriptor.NAME_OPERAND), methods);
  13.289 +            }
  13.290 +            default: {
  13.291 +                return null;
  13.292 +            }
  13.293 +        }
  13.294 +    }
  13.295 +
  13.296 +    private GuardedInvocation createGuardedDynamicMethodInvocation(MethodType callSiteType,
  13.297 +            LinkerServices linkerServices, String methodName, Map<String, DynamicMethod> methodMap){
  13.298 +        final MethodHandle inv = getDynamicMethodInvocation(callSiteType, linkerServices, methodName, methodMap);
  13.299 +        return inv == null ? null : new GuardedInvocation(inv, getClassGuard(callSiteType));
  13.300 +    }
  13.301 +
  13.302 +    private static MethodHandle getDynamicMethodInvocation(MethodType callSiteType, LinkerServices linkerServices,
  13.303 +            String methodName, Map<String, DynamicMethod> methodMap) {
  13.304 +        final DynamicMethod dynaMethod = getDynamicMethod(methodName, methodMap);
  13.305 +        return dynaMethod != null ? dynaMethod.getInvocation(callSiteType, linkerServices) : null;
  13.306 +    }
  13.307 +
  13.308 +    private static DynamicMethod getDynamicMethod(String methodName, Map<String, DynamicMethod> methodMap) {
  13.309 +        final DynamicMethod dynaMethod = methodMap.get(methodName);
  13.310 +        return dynaMethod != null ? dynaMethod : getExplicitSignatureDynamicMethod(methodName, methodMap);
  13.311 +    }
  13.312 +
  13.313 +    private static SimpleDynamicMethod getExplicitSignatureDynamicMethod(String methodName,
  13.314 +            Map<String, DynamicMethod> methodsMap) {
  13.315 +        // What's below is meant to support the "name(type, type, ...)" syntax that programmers can use in a method name
  13.316 +        // to manually pin down an exact overloaded variant. This is not usually required, as the overloaded method
  13.317 +        // resolution works correctly in almost every situation. However, in presence of many language-specific
  13.318 +        // conversions with a radically dynamic language, most overloaded methods will end up being constantly selected
  13.319 +        // at invocation time, so a programmer knowledgable of the situation might choose to pin down an exact overload
  13.320 +        // for performance reasons.
  13.321 +
  13.322 +        // Is the method name lexically of the form "name(types)"?
  13.323 +        final int lastChar = methodName.length() - 1;
  13.324 +        if(methodName.charAt(lastChar) != ')') {
  13.325 +            return null;
  13.326 +        }
  13.327 +        final int openBrace = methodName.indexOf('(');
  13.328 +        if(openBrace == -1) {
  13.329 +            return null;
  13.330 +        }
  13.331 +
  13.332 +        // Find an existing method for the "name" part
  13.333 +        final DynamicMethod simpleNamedMethod = methodsMap.get(methodName.substring(0, openBrace));
  13.334 +        if(simpleNamedMethod == null) {
  13.335 +            return null;
  13.336 +        }
  13.337 +
  13.338 +        // Try to get a narrowed dynamic method for the explicit parameter types.
  13.339 +        return simpleNamedMethod.getMethodForExactParamTypes(methodName.substring(openBrace + 1, lastChar));
  13.340 +    }
  13.341 +
  13.342 +    private static final MethodHandle IS_METHOD_HANDLE_NOT_NULL = Guards.isNotNull().asType(MethodType.methodType(
  13.343 +            boolean.class, MethodHandle.class));
  13.344 +    private static final MethodHandle CONSTANT_NULL_DROP_METHOD_HANDLE = MethodHandles.dropArguments(
  13.345 +            MethodHandles.constant(Object.class, null), 0, MethodHandle.class);
  13.346 +
  13.347 +    private GuardedInvocationComponent getPropertySetter(CallSiteDescriptor callSiteDescriptor,
  13.348 +            LinkerServices linkerServices, List<String> operations) throws Exception {
  13.349 +        final MethodType type = callSiteDescriptor.getMethodType();
  13.350 +        switch(callSiteDescriptor.getNameTokenCount()) {
  13.351 +            case 2: {
  13.352 +                // Must have three arguments: target object, property name, and property value.
  13.353 +                assertParameterCount(callSiteDescriptor, 3);
  13.354 +
  13.355 +                // What's below is basically:
  13.356 +                //   foldArguments(guardWithTest(isNotNull, invoke, null|nextComponent.invocation),
  13.357 +                //     get_setter_handle(type, linkerServices))
  13.358 +                // only with a bunch of method signature adjustments. Basically, retrieve method setter
  13.359 +                // MethodHandle; if it is non-null, invoke it, otherwise either return null, or delegate to next
  13.360 +                // component's invocation.
  13.361 +
  13.362 +                // Call site type is "ret_type(object_type,property_name_type,property_value_type)", which we'll
  13.363 +                // abbreviate to R(O, N, V) going forward.
  13.364 +                // We want setters that conform to "R(O, V)"
  13.365 +                final MethodType setterType = type.dropParameterTypes(1, 2);
  13.366 +                // Bind property setter handle to the expected setter type and linker services. Type is
  13.367 +                // MethodHandle(Object, String, Object)
  13.368 +                final MethodHandle boundGetter = MethodHandles.insertArguments(getPropertySetterHandle, 0, setterType,
  13.369 +                        linkerServices);
  13.370 +
  13.371 +                // Cast getter to MethodHandle(O, N, V)
  13.372 +                final MethodHandle typedGetter = linkerServices.asType(boundGetter, type.changeReturnType(
  13.373 +                        MethodHandle.class));
  13.374 +
  13.375 +                // Handle to invoke the setter R(MethodHandle, O, V)
  13.376 +                final MethodHandle invokeHandle = MethodHandles.exactInvoker(setterType);
  13.377 +                // Handle to invoke the setter, dropping unnecessary fold arguments R(MethodHandle, O, N, V)
  13.378 +                final MethodHandle invokeHandleFolded = MethodHandles.dropArguments(invokeHandle, 2, type.parameterType(
  13.379 +                        1));
  13.380 +                final GuardedInvocationComponent nextComponent = getGuardedInvocationComponent(callSiteDescriptor,
  13.381 +                        linkerServices, operations);
  13.382 +
  13.383 +                final MethodHandle fallbackFolded;
  13.384 +                if(nextComponent == null) {
  13.385 +                    // Object(MethodHandle)->R(MethodHandle, O, N, V); returns constant null
  13.386 +                    fallbackFolded = MethodHandles.dropArguments(CONSTANT_NULL_DROP_METHOD_HANDLE, 1,
  13.387 +                            type.parameterList()).asType(type.insertParameterTypes(0, MethodHandle.class));
  13.388 +                } else {
  13.389 +                    // R(O, N, V)->R(MethodHandle, O, N, V); adapts the next component's invocation to drop the
  13.390 +                    // extra argument resulting from fold
  13.391 +                    fallbackFolded = MethodHandles.dropArguments(nextComponent.getGuardedInvocation().getInvocation(),
  13.392 +                            0, MethodHandle.class);
  13.393 +                }
  13.394 +
  13.395 +                // fold(R(MethodHandle, O, N, V), MethodHandle(O, N, V))
  13.396 +                final MethodHandle compositeSetter = MethodHandles.foldArguments(MethodHandles.guardWithTest(
  13.397 +                            IS_METHOD_HANDLE_NOT_NULL, invokeHandleFolded, fallbackFolded), typedGetter);
  13.398 +                if(nextComponent == null) {
  13.399 +                    return getClassGuardedInvocationComponent(compositeSetter, type);
  13.400 +                } else {
  13.401 +                    return nextComponent.compose(compositeSetter, getClassGuard(type), clazz,
  13.402 +                            ValidationType.EXACT_CLASS);
  13.403 +                }
  13.404 +            }
  13.405 +            case 3: {
  13.406 +                // Must have two arguments: target object and property value
  13.407 +                assertParameterCount(callSiteDescriptor, 2);
  13.408 +                final GuardedInvocation gi = createGuardedDynamicMethodInvocation(callSiteDescriptor.getMethodType(),
  13.409 +                        linkerServices, callSiteDescriptor.getNameToken(CallSiteDescriptor.NAME_OPERAND),
  13.410 +                        propertySetters);
  13.411 +                // If we have a property setter with this name, this composite operation will always stop here
  13.412 +                if(gi != null) {
  13.413 +                    return new GuardedInvocationComponent(gi, clazz, ValidationType.EXACT_CLASS);
  13.414 +                }
  13.415 +                // If we don't have a property setter with this name, always fall back to the next operation in the
  13.416 +                // composite (if any)
  13.417 +                return getGuardedInvocationComponent(callSiteDescriptor, linkerServices, operations);
  13.418 +            }
  13.419 +            default: {
  13.420 +                // More than two name components; don't know what to do with it.
  13.421 +                return null;
  13.422 +            }
  13.423 +        }
  13.424 +    }
  13.425 +
  13.426 +    private static final Lookup privateLookup = new Lookup(MethodHandles.lookup());
  13.427 +
  13.428 +    private static final MethodHandle IS_ANNOTATED_HANDLE_NOT_NULL = Guards.isNotNull().asType(MethodType.methodType(
  13.429 +            boolean.class, AnnotatedMethodHandle.class));
  13.430 +    private static final MethodHandle CONSTANT_NULL_DROP_ANNOTATED_HANDLE = MethodHandles.dropArguments(
  13.431 +            MethodHandles.constant(Object.class, null), 0, AnnotatedMethodHandle.class);
  13.432 +    private static final MethodHandle GET_ANNOTATED_HANDLE = privateLookup.findGetter(AnnotatedMethodHandle.class,
  13.433 +            "handle", MethodHandle.class);
  13.434 +    private static final MethodHandle GENERIC_PROPERTY_GETTER_HANDLER_INVOKER = MethodHandles.filterArguments(
  13.435 +            MethodHandles.invoker(MethodType.methodType(Object.class, Object.class)), 0, GET_ANNOTATED_HANDLE);
  13.436 +
  13.437 +    private GuardedInvocationComponent getPropertyGetter(CallSiteDescriptor callSiteDescriptor,
  13.438 +            LinkerServices linkerServices, List<String> ops) throws Exception {
  13.439 +        final MethodType type = callSiteDescriptor.getMethodType();
  13.440 +        switch(callSiteDescriptor.getNameTokenCount()) {
  13.441 +            case 2: {
  13.442 +                // Must have exactly two arguments: receiver and name
  13.443 +                assertParameterCount(callSiteDescriptor, 2);
  13.444 +
  13.445 +                // What's below is basically:
  13.446 +                //   foldArguments(guardWithTest(isNotNull, invoke(get_handle), null|nextComponent.invocation), get_getter_handle)
  13.447 +                // only with a bunch of method signature adjustments. Basically, retrieve method getter
  13.448 +                // AnnotatedMethodHandle; if it is non-null, invoke its "handle" field, otherwise either return null,
  13.449 +                // or delegate to next component's invocation.
  13.450 +
  13.451 +                final MethodHandle typedGetter = linkerServices.asType(getPropertyGetterHandle, type.changeReturnType(
  13.452 +                        AnnotatedMethodHandle.class));
  13.453 +                // Object(AnnotatedMethodHandle, Object)->R(AnnotatedMethodHandle, T0)
  13.454 +                final MethodHandle invokeHandleTyped = linkerServices.asType(GENERIC_PROPERTY_GETTER_HANDLER_INVOKER,
  13.455 +                        MethodType.methodType(type.returnType(), AnnotatedMethodHandle.class, type.parameterType(0)));
  13.456 +                // Since it's in the target of a fold, drop the unnecessary second argument
  13.457 +                // R(AnnotatedMethodHandle, T0)->R(AnnotatedMethodHandle, T0, T1)
  13.458 +                final MethodHandle invokeHandleFolded = MethodHandles.dropArguments(invokeHandleTyped, 2,
  13.459 +                        type.parameterType(1));
  13.460 +                final GuardedInvocationComponent nextComponent = getGuardedInvocationComponent(callSiteDescriptor,
  13.461 +                        linkerServices, ops);
  13.462 +
  13.463 +                final MethodHandle fallbackFolded;
  13.464 +                if(nextComponent == null) {
  13.465 +                    // Object(AnnotatedMethodHandle)->R(AnnotatedMethodHandle, T0, T1); returns constant null
  13.466 +                    fallbackFolded = MethodHandles.dropArguments(CONSTANT_NULL_DROP_ANNOTATED_HANDLE, 1,
  13.467 +                            type.parameterList()).asType(type.insertParameterTypes(0, AnnotatedMethodHandle.class));
  13.468 +                } else {
  13.469 +                    // R(T0, T1)->R(AnnotatedMethodHAndle, T0, T1); adapts the next component's invocation to drop the
  13.470 +                    // extra argument resulting from fold
  13.471 +                    fallbackFolded = MethodHandles.dropArguments(nextComponent.getGuardedInvocation().getInvocation(),
  13.472 +                            0, AnnotatedMethodHandle.class);
  13.473 +                }
  13.474 +
  13.475 +                // fold(R(AnnotatedMethodHandle, T0, T1), AnnotatedMethodHandle(T0, T1))
  13.476 +                final MethodHandle compositeGetter = MethodHandles.foldArguments(MethodHandles.guardWithTest(
  13.477 +                            IS_ANNOTATED_HANDLE_NOT_NULL, invokeHandleFolded, fallbackFolded), typedGetter);
  13.478 +                if(nextComponent == null) {
  13.479 +                    return getClassGuardedInvocationComponent(compositeGetter, type);
  13.480 +                } else {
  13.481 +                    return nextComponent.compose(compositeGetter, getClassGuard(type), clazz,
  13.482 +                            ValidationType.EXACT_CLASS);
  13.483 +                }
  13.484 +            }
  13.485 +            case 3: {
  13.486 +                // Must have exactly one argument: receiver
  13.487 +                assertParameterCount(callSiteDescriptor, 1);
  13.488 +                // Fixed name
  13.489 +                final AnnotatedMethodHandle annGetter = propertyGetters.get(callSiteDescriptor.getNameToken(
  13.490 +                        CallSiteDescriptor.NAME_OPERAND));
  13.491 +                if(annGetter == null) {
  13.492 +                    // We have no such property, always delegate to the next component operation
  13.493 +                    return getGuardedInvocationComponent(callSiteDescriptor, linkerServices, ops);
  13.494 +                }
  13.495 +                final MethodHandle getter = annGetter.handle;
  13.496 +                // NOTE: since property getters (not field getters!) are no-arg, we don't have to worry about them being
  13.497 +                // overloaded in a subclass. Therefore, we can discover the most abstract superclass that has the
  13.498 +                // method, and use that as the guard with Guards.isInstance() for a more stably linked call site. If
  13.499 +                // we're linking against a field getter, don't make the assumption.
  13.500 +                // NOTE: No delegation to the next component operation if we have a property with this name, even if its
  13.501 +                // value is null.
  13.502 +                final ValidationType validationType = annGetter.validationType;
  13.503 +                return new GuardedInvocationComponent(linkerServices.asType(getter, type), getGuard(validationType,
  13.504 +                        type), clazz, validationType);
  13.505 +            }
  13.506 +            default: {
  13.507 +                // Can't do anything with more than 3 name components
  13.508 +                return null;
  13.509 +            }
  13.510 +        }
  13.511 +    }
  13.512 +
  13.513 +    private MethodHandle getGuard(ValidationType validationType, MethodType methodType) {
  13.514 +        switch(validationType) {
  13.515 +            case EXACT_CLASS: {
  13.516 +                return getClassGuard(methodType);
  13.517 +            }
  13.518 +            case INSTANCE_OF: {
  13.519 +                return getAssignableGuard(methodType);
  13.520 +            }
  13.521 +            case IS_ARRAY: {
  13.522 +                return Guards.isArray(0, methodType);
  13.523 +            }
  13.524 +            case NONE: {
  13.525 +                return null;
  13.526 +            }
  13.527 +        }
  13.528 +        throw new AssertionError();
  13.529 +    }
  13.530 +
  13.531 +    private static final MethodHandle IS_DYNAMIC_METHOD_NOT_NULL = Guards.asType(Guards.isNotNull(),
  13.532 +            MethodType.methodType(boolean.class, DynamicMethod.class));
  13.533 +    private static final MethodHandle DYNAMIC_METHOD_IDENTITY = MethodHandles.identity(DynamicMethod.class);
  13.534 +
  13.535 +    private GuardedInvocationComponent getMethodGetter(CallSiteDescriptor callSiteDescriptor,
  13.536 +            LinkerServices linkerServices, List<String> ops) throws Exception {
  13.537 +        final MethodType type = callSiteDescriptor.getMethodType();
  13.538 +        switch(callSiteDescriptor.getNameTokenCount()) {
  13.539 +            case 2: {
  13.540 +                // Must have exactly two arguments: receiver and name
  13.541 +                assertParameterCount(callSiteDescriptor, 2);
  13.542 +                final GuardedInvocationComponent nextComponent = getGuardedInvocationComponent(callSiteDescriptor,
  13.543 +                        linkerServices, ops);
  13.544 +                if(nextComponent == null) {
  13.545 +                    // No next component operation; just return a component for this operation.
  13.546 +                    return getClassGuardedInvocationComponent(linkerServices.asType(getDynamicMethod, type), type);
  13.547 +                } else {
  13.548 +                    // What's below is basically:
  13.549 +                    //   foldArguments(guardWithTest(isNotNull, identity, nextComponent.invocation), getter)
  13.550 +                    // only with a bunch of method signature adjustments. Basically, execute method getter; if
  13.551 +                    // it returns a non-null DynamicMethod, use identity to return it, otherwise delegate to
  13.552 +                    // nextComponent's invocation.
  13.553 +
  13.554 +                    final MethodHandle typedGetter = linkerServices.asType(getDynamicMethod, type.changeReturnType(
  13.555 +                            DynamicMethod.class));
  13.556 +                    // Since it is part of the foldArgument() target, it will have extra args that we need to drop.
  13.557 +                    final MethodHandle returnMethodHandle = linkerServices.asType(MethodHandles.dropArguments(
  13.558 +                            DYNAMIC_METHOD_IDENTITY, 1, type.parameterList()), type.insertParameterTypes(0,
  13.559 +                                    DynamicMethod.class));
  13.560 +                    final MethodHandle nextComponentInvocation = nextComponent.getGuardedInvocation().getInvocation();
  13.561 +                    // The assumption is that getGuardedInvocationComponent() already asType()'d it correctly
  13.562 +                    assert nextComponentInvocation.type().equals(type);
  13.563 +                    // Since it is part of the foldArgument() target, we have to drop an extra arg it receives.
  13.564 +                    final MethodHandle nextCombinedInvocation = MethodHandles.dropArguments(nextComponentInvocation, 0,
  13.565 +                            DynamicMethod.class);
  13.566 +                    // Assemble it all into a fold(guard(isNotNull, identity, nextInvocation), get)
  13.567 +                    final MethodHandle compositeGetter = MethodHandles.foldArguments(MethodHandles.guardWithTest(
  13.568 +                            IS_DYNAMIC_METHOD_NOT_NULL, returnMethodHandle, nextCombinedInvocation), typedGetter);
  13.569 +
  13.570 +                    return nextComponent.compose(compositeGetter, getClassGuard(type), clazz,
  13.571 +                            ValidationType.EXACT_CLASS);
  13.572 +                }
  13.573 +            }
  13.574 +            case 3: {
  13.575 +                // Must have exactly one argument: receiver
  13.576 +                assertParameterCount(callSiteDescriptor, 1);
  13.577 +                final DynamicMethod method = getDynamicMethod(callSiteDescriptor.getNameToken(
  13.578 +                        CallSiteDescriptor.NAME_OPERAND));
  13.579 +                if(method == null) {
  13.580 +                    // We have no such method, always delegate to the next component
  13.581 +                    return getGuardedInvocationComponent(callSiteDescriptor, linkerServices, ops);
  13.582 +                }
  13.583 +                // No delegation to the next component of the composite operation; if we have a method with that name,
  13.584 +                // we'll always return it at this point.
  13.585 +                return getClassGuardedInvocationComponent(linkerServices.asType(MethodHandles.dropArguments(
  13.586 +                        MethodHandles.constant(DynamicMethod.class, method), 0, type.parameterType(0)), type), type);
  13.587 +            }
  13.588 +            default: {
  13.589 +                // Can't do anything with more than 3 name components
  13.590 +                return null;
  13.591 +            }
  13.592 +        }
  13.593 +    }
  13.594 +
  13.595 +    private static void assertParameterCount(CallSiteDescriptor descriptor, int paramCount) {
  13.596 +        if(descriptor.getMethodType().parameterCount() != paramCount) {
  13.597 +            throw new BootstrapMethodError(descriptor.getName() + " must have exactly " + paramCount + " parameters.");
  13.598 +        }
  13.599 +    }
  13.600 +
  13.601 +    private static MethodHandle GET_PROPERTY_GETTER_HANDLE = MethodHandles.dropArguments(privateLookup.findOwnSpecial(
  13.602 +            "getPropertyGetterHandle", Object.class, Object.class), 1, Object.class);
  13.603 +    private final MethodHandle getPropertyGetterHandle = GET_PROPERTY_GETTER_HANDLE.bindTo(this);
  13.604 +
  13.605 +    /**
  13.606 +     * @param id the property ID
  13.607 +     * @return the method handle for retrieving the property, or null if the property does not exist
  13.608 +     */
  13.609 +    @SuppressWarnings("unused")
  13.610 +    private Object getPropertyGetterHandle(Object id) {
  13.611 +        return propertyGetters.get(id);
  13.612 +    }
  13.613 +
  13.614 +    // Type is MethodHandle(BeanLinker, MethodType, LinkerServices, Object, String, Object), of which the two "Object"
  13.615 +    // args are dropped; this makes handles with first three args conform to "Object, String, Object" though, which is
  13.616 +    // a typical property setter with variable name signature (target, name, value).
  13.617 +    private static final MethodHandle GET_PROPERTY_SETTER_HANDLE = MethodHandles.dropArguments(MethodHandles.dropArguments(
  13.618 +            privateLookup.findOwnSpecial("getPropertySetterHandle", MethodHandle.class, MethodType.class,
  13.619 +                    LinkerServices.class, Object.class), 3, Object.class), 5, Object.class);
  13.620 +    // Type is MethodHandle(MethodType, LinkerServices, Object, String, Object)
  13.621 +    private final MethodHandle getPropertySetterHandle = GET_PROPERTY_SETTER_HANDLE.bindTo(this);
  13.622 +
  13.623 +    @SuppressWarnings("unused")
  13.624 +    private MethodHandle getPropertySetterHandle(MethodType setterType, LinkerServices linkerServices, Object id) {
  13.625 +        return getDynamicMethodInvocation(setterType, linkerServices, String.valueOf(id), propertySetters);
  13.626 +    }
  13.627 +
  13.628 +    private static MethodHandle GET_DYNAMIC_METHOD = MethodHandles.dropArguments(privateLookup.findOwnSpecial(
  13.629 +            "getDynamicMethod", DynamicMethod.class, Object.class), 1, Object.class);
  13.630 +    private final MethodHandle getDynamicMethod = GET_DYNAMIC_METHOD.bindTo(this);
  13.631 +
  13.632 +    @SuppressWarnings("unused")
  13.633 +    private DynamicMethod getDynamicMethod(Object name) {
  13.634 +        return getDynamicMethod(String.valueOf(name), methods);
  13.635 +    }
  13.636 +
  13.637 +    /**
  13.638 +     * Returns a dynamic method of the specified name.
  13.639 +     *
  13.640 +     * @param name name of the method
  13.641 +     * @return the dynamic method (either {@link SimpleDynamicMethod} or {@link OverloadedDynamicMethod}, or null if the
  13.642 +     * method with the specified name does not exist.
  13.643 +     */
  13.644 +    public DynamicMethod getDynamicMethod(String name) {
  13.645 +        return getDynamicMethod(name, methods);
  13.646 +    }
  13.647 +
  13.648 +    /**
  13.649 +     * Find the most generic superclass that declares this getter. Since getters have zero args (aside from the
  13.650 +     * receiver), they can't be overloaded, so we're free to link with an instanceof guard for the most generic one,
  13.651 +     * creating more stable call sites.
  13.652 +     * @param getter the getter
  13.653 +     * @return getter with same name, declared on the most generic superclass/interface of the declaring class
  13.654 +     */
  13.655 +    private static Method getMostGenericGetter(Method getter) {
  13.656 +        return getMostGenericGetter(getter.getName(), getter.getReturnType(), getter.getDeclaringClass());
  13.657 +    }
  13.658 +
  13.659 +    private static Method getMostGenericGetter(String name, Class<?> returnType, Class<?> declaringClass) {
  13.660 +        if(declaringClass == null) {
  13.661 +            return null;
  13.662 +        }
  13.663 +        // Prefer interfaces
  13.664 +        for(Class<?> itf: declaringClass.getInterfaces()) {
  13.665 +            final Method itfGetter = getMostGenericGetter(name, returnType, itf);
  13.666 +            if(itfGetter != null) {
  13.667 +                return itfGetter;
  13.668 +            }
  13.669 +        }
  13.670 +        final Method superGetter = getMostGenericGetter(name, returnType, declaringClass.getSuperclass());
  13.671 +        if(superGetter != null) {
  13.672 +            return superGetter;
  13.673 +        }
  13.674 +        if(!CheckRestrictedPackage.isRestrictedClass(declaringClass)) {
  13.675 +            try {
  13.676 +                return declaringClass.getMethod(name);
  13.677 +            } catch(NoSuchMethodException e) {
  13.678 +                // Intentionally ignored, meant to fall through
  13.679 +            }
  13.680 +        }
  13.681 +        return null;
  13.682 +    }
  13.683 +
  13.684 +    private static final class AnnotatedMethodHandle {
  13.685 +        final MethodHandle handle;
  13.686 +        /*private*/ final ValidationType validationType;
  13.687 +
  13.688 +        AnnotatedMethodHandle(MethodHandle handle, ValidationType validationType) {
  13.689 +            this.handle = handle;
  13.690 +            this.validationType = validationType;
  13.691 +        }
  13.692 +    }
  13.693 +}
  13.694 \ No newline at end of file

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/src/jdk/internal/dynalink/beans/AccessibleMembersLookup.java	Thu Feb 14 13:22:26 2013 +0100
    14.3 @@ -0,0 +1,262 @@
    14.4 +/*
    14.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    14.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    14.7 + *
    14.8 + * This code is free software; you can redistribute it and/or modify it
    14.9 + * under the terms of the GNU General Public License version 2 only, as
   14.10 + * published by the Free Software Foundation.  Oracle designates this
   14.11 + * particular file as subject to the "Classpath" exception as provided
   14.12 + * by Oracle in the LICENSE file that accompanied this code.
   14.13 + *
   14.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   14.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14.17 + * version 2 for more details (a copy is included in the LICENSE file that
   14.18 + * accompanied this code).
   14.19 + *
   14.20 + * You should have received a copy of the GNU General Public License version
   14.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   14.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   14.23 + *
   14.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   14.25 + * or visit www.oracle.com if you need additional information or have any
   14.26 + * questions.
   14.27 + */
   14.28 +
   14.29 +/*
   14.30 + * This file is available under and governed by the GNU General Public
   14.31 + * License version 2 only, as published by the Free Software Foundation.
   14.32 + * However, the following notice accompanied the original version of this
   14.33 + * file, and Oracle licenses the original version of this file under the BSD
   14.34 + * license:
   14.35 + */
   14.36 +/*
   14.37 +   Copyright 2009-2013 Attila Szegedi
   14.38 +
   14.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   14.40 +   and the BSD License (the "BSD License"), with licensee being free to
   14.41 +   choose either of the two at their discretion.
   14.42 +
   14.43 +   You may not use this file except in compliance with either the Apache
   14.44 +   License or the BSD License.
   14.45 +
   14.46 +   If you choose to use this file in compliance with the Apache License, the
   14.47 +   following notice applies to you:
   14.48 +
   14.49 +       You may obtain a copy of the Apache License at
   14.50 +
   14.51 +           http://www.apache.org/licenses/LICENSE-2.0
   14.52 +
   14.53 +       Unless required by applicable law or agreed to in writing, software
   14.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   14.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   14.56 +       implied. See the License for the specific language governing
   14.57 +       permissions and limitations under the License.
   14.58 +
   14.59 +   If you choose to use this file in compliance with the BSD License, the
   14.60 +   following notice applies to you:
   14.61 +
   14.62 +       Redistribution and use in source and binary forms, with or without
   14.63 +       modification, are permitted provided that the following conditions are
   14.64 +       met:
   14.65 +       * Redistributions of source code must retain the above copyright
   14.66 +         notice, this list of conditions and the following disclaimer.
   14.67 +       * Redistributions in binary form must reproduce the above copyright
   14.68 +         notice, this list of conditions and the following disclaimer in the
   14.69 +         documentation and/or other materials provided with the distribution.
   14.70 +       * Neither the name of the copyright holder nor the names of
   14.71 +         contributors may be used to endorse or promote products derived from
   14.72 +         this software without specific prior written permission.
   14.73 +
   14.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   14.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   14.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   14.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   14.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   14.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   14.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   14.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   14.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   14.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   14.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   14.85 +*/
   14.86 +
   14.87 +package jdk.internal.dynalink.beans;
   14.88 +
   14.89 +import java.lang.reflect.Method;
   14.90 +import java.lang.reflect.Modifier;
   14.91 +import java.util.Arrays;
   14.92 +import java.util.Collection;
   14.93 +import java.util.HashMap;
   14.94 +import java.util.LinkedHashSet;
   14.95 +import java.util.Map;
   14.96 +import java.util.Set;
   14.97 +
   14.98 +/**
   14.99 + * Utility class for discovering accessible methods and inner classes. Normally, a public member declared on a class is
  14.100 + * accessible (that is, it can be invoked from anywhere). However, this is not the case if the class itself is not
  14.101 + * public, or belongs to a restricted-access package. In that case, it is required to lookup a member in a publicly
  14.102 + * accessible superclass or implemented interface of the class, and use it instead of the member discovered on the
  14.103 + * class.
  14.104 + *
  14.105 + * @author Attila Szegedi
  14.106 + */
  14.107 +class AccessibleMembersLookup {
  14.108 +    private final Map<MethodSignature, Method> methods;
  14.109 +    private final Set<Class<?>> innerClasses;
  14.110 +    private boolean instance;
  14.111 +
  14.112 +    /**
  14.113 +     * Creates a mapping for all accessible methods and inner classes on a class.
  14.114 +     *
  14.115 +     * @param clazz the inspected class
  14.116 +     * @param instance true to inspect instance methods, false to inspect static methods.
  14.117 +     */
  14.118 +    AccessibleMembersLookup(final Class<?> clazz, boolean instance) {
  14.119 +        this.methods = new HashMap<>();
  14.120 +        this.innerClasses = new LinkedHashSet<>();
  14.121 +        this.instance = instance;
  14.122 +        lookupAccessibleMembers(clazz);
  14.123 +    }
  14.124 +
  14.125 +    /**
  14.126 +     * Returns an accessible method equivalent of a method.
  14.127 +     *
  14.128 +     * @param m the method whose accessible equivalent is requested.
  14.129 +     * @return the accessible equivalent for the method (can be the same as the passed in method), or null if there is
  14.130 +     * no accessible method equivalent.
  14.131 +     */
  14.132 +    Method getAccessibleMethod(final Method m) {
  14.133 +        return m == null ? null : methods.get(new MethodSignature(m));
  14.134 +    }
  14.135 +
  14.136 +    Collection<Method> getMethods() {
  14.137 +        return methods.values();
  14.138 +    }
  14.139 +
  14.140 +    Class<?>[] getInnerClasses() {
  14.141 +        return innerClasses.toArray(new Class<?>[innerClasses.size()]);
  14.142 +    }
  14.143 +
  14.144 +    /**
  14.145 +     * A helper class that represents a method signature - name and argument types.
  14.146 +     *
  14.147 +     * @author Attila Szegedi
  14.148 +     */
  14.149 +    static final class MethodSignature {
  14.150 +        private final String name;
  14.151 +        private final Class<?>[] args;
  14.152 +
  14.153 +        /**
  14.154 +         * Creates a new method signature from arbitrary data.
  14.155 +         *
  14.156 +         * @param name the name of the method this signature represents.
  14.157 +         * @param args the argument types of the method.
  14.158 +         */
  14.159 +        MethodSignature(String name, Class<?>[] args) {
  14.160 +            this.name = name;
  14.161 +            this.args = args;
  14.162 +        }
  14.163 +
  14.164 +        /**
  14.165 +         * Creates a signature for the given method.
  14.166 +         *
  14.167 +         * @param method the method for which a signature is created.
  14.168 +         */
  14.169 +        MethodSignature(final Method method) {
  14.170 +            this(method.getName(), method.getParameterTypes());
  14.171 +        }
  14.172 +
  14.173 +        /**
  14.174 +         * Compares this object to another object
  14.175 +         *
  14.176 +         * @param o the other object
  14.177 +         * @return true if the other object is also a method signature with the same name, same number of arguments, and
  14.178 +         * same types of arguments.
  14.179 +         */
  14.180 +        @Override
  14.181 +        public boolean equals(final Object o) {
  14.182 +            if(o instanceof MethodSignature) {
  14.183 +                final MethodSignature ms = (MethodSignature)o;
  14.184 +                return ms.name.equals(name) && Arrays.equals(args, ms.args);
  14.185 +            }
  14.186 +            return false;
  14.187 +        }
  14.188 +
  14.189 +        /**
  14.190 +         * Returns a hash code, consistent with the overridden {@link #equals(Object)}.
  14.191 +         */
  14.192 +        @Override
  14.193 +        public int hashCode() {
  14.194 +            return name.hashCode() ^ Arrays.hashCode(args);
  14.195 +        }
  14.196 +
  14.197 +        @Override
  14.198 +        public String toString() {
  14.199 +            final StringBuilder b = new StringBuilder();
  14.200 +            b.append("[MethodSignature ").append(name).append('(');
  14.201 +            if(args.length > 0) {
  14.202 +                b.append(args[0].getCanonicalName());
  14.203 +                for(int i = 1; i < args.length; ++i) {
  14.204 +                    b.append(", ").append(args[i].getCanonicalName());
  14.205 +                }
  14.206 +            }
  14.207 +            return b.append(")]").toString();
  14.208 +        }
  14.209 +    }
  14.210 +
  14.211 +    private void lookupAccessibleMembers(final Class<?> clazz) {
  14.212 +        boolean searchSuperTypes;
  14.213 +
  14.214 +        if(!CheckRestrictedPackage.isRestrictedClass(clazz)) {
  14.215 +            searchSuperTypes = false;
  14.216 +            for(Method method: clazz.getMethods()) {
  14.217 +                if(instance != Modifier.isStatic(method.getModifiers())) {
  14.218 +                    final MethodSignature sig = new MethodSignature(method);
  14.219 +                    if(!methods.containsKey(sig)) {
  14.220 +                        final Class<?> declaringClass = method.getDeclaringClass();
  14.221 +                        if(declaringClass != clazz && CheckRestrictedPackage.isRestrictedClass(declaringClass)) {
  14.222 +                            //Sometimes, the declaring class of a method (Method.getDeclaringClass())
  14.223 +                            //retrieved through Class.getMethods() for a public class will be a
  14.224 +                            //non-public superclass. For such a method, we need to find a method with
  14.225 +                            //the same name and signature in a public superclass or implemented
  14.226 +                            //interface.
  14.227 +                            //This typically doesn't happen with classes emitted by a reasonably modern
  14.228 +                            //javac, as it'll create synthetic delegator methods in all public
  14.229 +                            //immediate subclasses of the non-public class. We have, however, observed
  14.230 +                            //this in the wild with class files compiled with older javac that doesn't
  14.231 +                            //generate the said synthetic delegators.
  14.232 +                            searchSuperTypes = true;
  14.233 +                        } else {
  14.234 +                            methods.put(sig, method);
  14.235 +                        }
  14.236 +                    }
  14.237 +                }
  14.238 +            }
  14.239 +            for(Class<?> innerClass: clazz.getClasses()) {
  14.240 +                // Add both static and non-static classes, regardless of instance flag. StaticClassLinker will just
  14.241 +                // expose non-static classes with explicit constructor outer class argument.
  14.242 +                // NOTE: getting inner class objects through getClasses() does not resolve them, so if those classes
  14.243 +                // were not yet loaded, they'll only get loaded in a non-resolved state; no static initializers for
  14.244 +                // them will trigger just by doing this.
  14.245 +                innerClasses.add(innerClass);
  14.246 +            }
  14.247 +        } else {
  14.248 +            searchSuperTypes = true;
  14.249 +        }
  14.250 +
  14.251 +        if(searchSuperTypes) {
  14.252 +            // If we reach here, the class is either not public, or it is in a restricted package. Alternatively, it is
  14.253 +            // public, but some of its methods claim that their declaring class is non-public. We'll try superclasses
  14.254 +            // and implemented interfaces then looking for public ones.
  14.255 +            final Class<?>[] interfaces = clazz.getInterfaces();
  14.256 +            for(int i = 0; i < interfaces.length; i++) {
  14.257 +                lookupAccessibleMembers(interfaces[i]);
  14.258 +            }
  14.259 +            final Class<?> superclass = clazz.getSuperclass();
  14.260 +            if(superclass != null) {
  14.261 +                lookupAccessibleMembers(superclass);
  14.262 +            }
  14.263 +        }
  14.264 +    }
  14.265 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/src/jdk/internal/dynalink/beans/ApplicableOverloadedMethods.java	Thu Feb 14 13:22:26 2013 +0100
    15.3 @@ -0,0 +1,221 @@
    15.4 +/*
    15.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    15.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    15.7 + *
    15.8 + * This code is free software; you can redistribute it and/or modify it
    15.9 + * under the terms of the GNU General Public License version 2 only, as
   15.10 + * published by the Free Software Foundation.  Oracle designates this
   15.11 + * particular file as subject to the "Classpath" exception as provided
   15.12 + * by Oracle in the LICENSE file that accompanied this code.
   15.13 + *
   15.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   15.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   15.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   15.17 + * version 2 for more details (a copy is included in the LICENSE file that
   15.18 + * accompanied this code).
   15.19 + *
   15.20 + * You should have received a copy of the GNU General Public License version
   15.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   15.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   15.23 + *
   15.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   15.25 + * or visit www.oracle.com if you need additional information or have any
   15.26 + * questions.
   15.27 + */
   15.28 +
   15.29 +/*
   15.30 + * This file is available under and governed by the GNU General Public
   15.31 + * License version 2 only, as published by the Free Software Foundation.
   15.32 + * However, the following notice accompanied the original version of this
   15.33 + * file, and Oracle licenses the original version of this file under the BSD
   15.34 + * license:
   15.35 + */
   15.36 +/*
   15.37 +   Copyright 2009-2013 Attila Szegedi
   15.38 +
   15.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   15.40 +   and the BSD License (the "BSD License"), with licensee being free to
   15.41 +   choose either of the two at their discretion.
   15.42 +
   15.43 +   You may not use this file except in compliance with either the Apache
   15.44 +   License or the BSD License.
   15.45 +
   15.46 +   If you choose to use this file in compliance with the Apache License, the
   15.47 +   following notice applies to you:
   15.48 +
   15.49 +       You may obtain a copy of the Apache License at
   15.50 +
   15.51 +           http://www.apache.org/licenses/LICENSE-2.0
   15.52 +
   15.53 +       Unless required by applicable law or agreed to in writing, software
   15.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   15.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   15.56 +       implied. See the License for the specific language governing
   15.57 +       permissions and limitations under the License.
   15.58 +
   15.59 +   If you choose to use this file in compliance with the BSD License, the
   15.60 +   following notice applies to you:
   15.61 +
   15.62 +       Redistribution and use in source and binary forms, with or without
   15.63 +       modification, are permitted provided that the following conditions are
   15.64 +       met:
   15.65 +       * Redistributions of source code must retain the above copyright
   15.66 +         notice, this list of conditions and the following disclaimer.
   15.67 +       * Redistributions in binary form must reproduce the above copyright
   15.68 +         notice, this list of conditions and the following disclaimer in the
   15.69 +         documentation and/or other materials provided with the distribution.
   15.70 +       * Neither the name of the copyright holder nor the names of
   15.71 +         contributors may be used to endorse or promote products derived from
   15.72 +         this software without specific prior written permission.
   15.73 +
   15.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   15.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   15.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   15.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   15.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   15.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   15.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   15.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   15.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   15.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   15.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   15.85 +*/
   15.86 +
   15.87 +package jdk.internal.dynalink.beans;
   15.88 +
   15.89 +import java.lang.invoke.MethodHandle;
   15.90 +import java.lang.invoke.MethodType;
   15.91 +import java.util.LinkedList;
   15.92 +import java.util.List;
   15.93 +import jdk.internal.dynalink.support.TypeUtilities;
   15.94 +
   15.95 +
   15.96 +/**
   15.97 + * Represents overloaded methods applicable to a specific call site signature.
   15.98 + *
   15.99 + * @author Attila Szegedi
  15.100 + */
  15.101 +class ApplicableOverloadedMethods {
  15.102 +    private final List<MethodHandle> methods;
  15.103 +    private final boolean varArgs;
  15.104 +
  15.105 +    /**
  15.106 +     * Creates a new ApplicableOverloadedMethods instance
  15.107 +     *
  15.108 +     * @param methods a list of all overloaded methods with the same name for a class.
  15.109 +     * @param callSiteType the type of the call site
  15.110 +     * @param test applicability test. One of {@link #APPLICABLE_BY_SUBTYPING},
  15.111 +     * {@link #APPLICABLE_BY_METHOD_INVOCATION_CONVERSION}, or {@link #APPLICABLE_BY_VARIABLE_ARITY}.
  15.112 +     */
  15.113 +    ApplicableOverloadedMethods(final List<MethodHandle> methods, final MethodType callSiteType,
  15.114 +            final ApplicabilityTest test) {
  15.115 +        this.methods = new LinkedList<>();
  15.116 +        for(MethodHandle m: methods) {
  15.117 +            if(test.isApplicable(callSiteType, m)) {
  15.118 +                this.methods.add(m);
  15.119 +            }
  15.120 +        }
  15.121 +        varArgs = test == APPLICABLE_BY_VARIABLE_ARITY;
  15.122 +    }
  15.123 +
  15.124 +    /**
  15.125 +     * Retrieves all the methods this object holds.
  15.126 +     *
  15.127 +     * @return list of all methods.
  15.128 +     */
  15.129 +    List<MethodHandle> getMethods() {
  15.130 +        return methods;
  15.131 +    }
  15.132 +
  15.133 +    /**
  15.134 +     * Returns a list of all methods in this objects that are maximally specific.
  15.135 +     *
  15.136 +     * @return a list of maximally specific methods.
  15.137 +     */
  15.138 +    List<MethodHandle> findMaximallySpecificMethods() {
  15.139 +        return MaximallySpecific.getMaximallySpecificMethods(methods, varArgs);
  15.140 +    }
  15.141 +
  15.142 +    abstract static class ApplicabilityTest {
  15.143 +        abstract boolean isApplicable(MethodType callSiteType, MethodHandle method);
  15.144 +    }
  15.145 +
  15.146 +    /**
  15.147 +     * Implements the applicability-by-subtyping test from JLS 15.12.2.2.
  15.148 +     */
  15.149 +    static final ApplicabilityTest APPLICABLE_BY_SUBTYPING = new ApplicabilityTest() {
  15.150 +        @Override
  15.151 +        boolean isApplicable(MethodType callSiteType, MethodHandle method) {
  15.152 +            final MethodType methodType = method.type();
  15.153 +            final int methodArity = methodType.parameterCount();
  15.154 +            if(methodArity != callSiteType.parameterCount()) {
  15.155 +                return false;
  15.156 +            }
  15.157 +            // 0th arg is receiver; it doesn't matter for overload
  15.158 +            // resolution.
  15.159 +            for(int i = 1; i < methodArity; ++i) {
  15.160 +                if(!TypeUtilities.isSubtype(callSiteType.parameterType(i), methodType.parameterType(i))) {
  15.161 +                    return false;
  15.162 +                }
  15.163 +            }
  15.164 +            return true;
  15.165 +        }
  15.166 +    };
  15.167 +
  15.168 +    /**
  15.169 +     * Implements the applicability-by-method-invocation-conversion test from JLS 15.12.2.3.
  15.170 +     */
  15.171 +    static final ApplicabilityTest APPLICABLE_BY_METHOD_INVOCATION_CONVERSION = new ApplicabilityTest() {
  15.172 +        @Override
  15.173 +        boolean isApplicable(MethodType callSiteType, MethodHandle method) {
  15.174 +            final MethodType methodType = method.type();
  15.175 +            final int methodArity = methodType.parameterCount();
  15.176 +            if(methodArity != callSiteType.parameterCount()) {
  15.177 +                return false;
  15.178 +            }
  15.179 +            // 0th arg is receiver; it doesn't matter for overload
  15.180 +            // resolution.
  15.181 +            for(int i = 1; i < methodArity; ++i) {
  15.182 +                if(!TypeUtilities.isMethodInvocationConvertible(callSiteType.parameterType(i),
  15.183 +                        methodType.parameterType(i))) {
  15.184 +                    return false;
  15.185 +                }
  15.186 +            }
  15.187 +            return true;
  15.188 +        }
  15.189 +    };
  15.190 +
  15.191 +    /**
  15.192 +     * Implements the applicability-by-variable-arity test from JLS 15.12.2.4.
  15.193 +     */
  15.194 +    static final ApplicabilityTest APPLICABLE_BY_VARIABLE_ARITY = new ApplicabilityTest() {
  15.195 +        @Override
  15.196 +        boolean isApplicable(MethodType callSiteType, MethodHandle method) {
  15.197 +            if(!method.isVarargsCollector()) {
  15.198 +                return false;
  15.199 +            }
  15.200 +            final MethodType methodType = method.type();
  15.201 +            final int methodArity = methodType.parameterCount();
  15.202 +            final int fixArity = methodArity - 1;
  15.203 +            final int callSiteArity = callSiteType.parameterCount();
  15.204 +            if(fixArity > callSiteArity) {
  15.205 +                return false;
  15.206 +            }
  15.207 +            // 0th arg is receiver; it doesn't matter for overload
  15.208 +            // resolution.
  15.209 +            for(int i = 1; i < fixArity; ++i) {
  15.210 +                if(!TypeUtilities.isMethodInvocationConvertible(callSiteType.parameterType(i),
  15.211 +                        methodType.parameterType(i))) {
  15.212 +                    return false;
  15.213 +                }
  15.214 +            }
  15.215 +            final Class<?> varArgType = methodType.parameterType(fixArity).getComponentType();
  15.216 +            for(int i = fixArity; i < callSiteArity; ++i) {
  15.217 +                if(!TypeUtilities.isMethodInvocationConvertible(callSiteType.parameterType(i), varArgType)) {
  15.218 +                    return false;
  15.219 +                }
  15.220 +            }
  15.221 +            return true;
  15.222 +        }
  15.223 +    };
  15.224 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/src/jdk/internal/dynalink/beans/BeanIntrospector.java	Thu Feb 14 13:22:26 2013 +0100
    16.3 @@ -0,0 +1,104 @@
    16.4 +/*
    16.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    16.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    16.7 + *
    16.8 + * This code is free software; you can redistribute it and/or modify it
    16.9 + * under the terms of the GNU General Public License version 2 only, as
   16.10 + * published by the Free Software Foundation.  Oracle designates this
   16.11 + * particular file as subject to the "Classpath" exception as provided
   16.12 + * by Oracle in the LICENSE file that accompanied this code.
   16.13 + *
   16.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   16.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   16.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   16.17 + * version 2 for more details (a copy is included in the LICENSE file that
   16.18 + * accompanied this code).
   16.19 + *
   16.20 + * You should have received a copy of the GNU General Public License version
   16.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   16.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   16.23 + *
   16.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   16.25 + * or visit www.oracle.com if you need additional information or have any
   16.26 + * questions.
   16.27 + */
   16.28 +
   16.29 +/*
   16.30 + * This file is available under and governed by the GNU General Public
   16.31 + * License version 2 only, as published by the Free Software Foundation.
   16.32 + * However, the following notice accompanied the original version of this
   16.33 + * file, and Oracle licenses the original version of this file under the BSD
   16.34 + * license:
   16.35 + */
   16.36 +/*
   16.37 +   Copyright 2009-2013 Attila Szegedi
   16.38 +
   16.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   16.40 +   and the BSD License (the "BSD License"), with licensee being free to
   16.41 +   choose either of the two at their discretion.
   16.42 +
   16.43 +   You may not use this file except in compliance with either the Apache
   16.44 +   License or the BSD License.
   16.45 +
   16.46 +   If you choose to use this file in compliance with the Apache License, the
   16.47 +   following notice applies to you:
   16.48 +
   16.49 +       You may obtain a copy of the Apache License at
   16.50 +
   16.51 +           http://www.apache.org/licenses/LICENSE-2.0
   16.52 +
   16.53 +       Unless required by applicable law or agreed to in writing, software
   16.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   16.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   16.56 +       implied. See the License for the specific language governing
   16.57 +       permissions and limitations under the License.
   16.58 +
   16.59 +   If you choose to use this file in compliance with the BSD License, the
   16.60 +   following notice applies to you:
   16.61 +
   16.62 +       Redistribution and use in source and binary forms, with or without
   16.63 +       modification, are permitted provided that the following conditions are
   16.64 +       met:
   16.65 +       * Redistributions of source code must retain the above copyright
   16.66 +         notice, this list of conditions and the following disclaimer.
   16.67 +       * Redistributions in binary form must reproduce the above copyright
   16.68 +         notice, this list of conditions and the following disclaimer in the
   16.69 +         documentation and/or other materials provided with the distribution.
   16.70 +       * Neither the name of the copyright holder nor the names of
   16.71 +         contributors may be used to endorse or promote products derived from
   16.72 +         this software without specific prior written permission.
   16.73 +
   16.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   16.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   16.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   16.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   16.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   16.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   16.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   16.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   16.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   16.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   16.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   16.85 +*/
   16.86 +
   16.87 +package jdk.internal.dynalink.beans;
   16.88 +
   16.89 +import java.lang.invoke.MethodHandle;
   16.90 +import java.util.Collections;
   16.91 +import java.util.Map;
   16.92 +
   16.93 +class BeanIntrospector extends FacetIntrospector {
   16.94 +    BeanIntrospector(Class<?> clazz) {
   16.95 +        super(clazz, true);
   16.96 +    }
   16.97 +
   16.98 +    @Override
   16.99 +    Map<String, MethodHandle> getInnerClassGetters() {
  16.100 +        return Collections.emptyMap(); // NOTE: non-static inner classes are also on StaticClassIntrospector.
  16.101 +    }
  16.102 +
  16.103 +    @Override
  16.104 +    MethodHandle editMethodHandle(MethodHandle mh) {
  16.105 +        return mh;
  16.106 +    }
  16.107 +}

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/src/jdk/internal/dynalink/beans/BeanLinker.java	Thu Feb 14 13:22:26 2013 +0100
    17.3 @@ -0,0 +1,493 @@
    17.4 +/*
    17.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    17.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.7 + *
    17.8 + * This code is free software; you can redistribute it and/or modify it
    17.9 + * under the terms of the GNU General Public License version 2 only, as
   17.10 + * published by the Free Software Foundation.  Oracle designates this
   17.11 + * particular file as subject to the "Classpath" exception as provided
   17.12 + * by Oracle in the LICENSE file that accompanied this code.
   17.13 + *
   17.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   17.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   17.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   17.17 + * version 2 for more details (a copy is included in the LICENSE file that
   17.18 + * accompanied this code).
   17.19 + *
   17.20 + * You should have received a copy of the GNU General Public License version
   17.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   17.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   17.23 + *
   17.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   17.25 + * or visit www.oracle.com if you need additional information or have any
   17.26 + * questions.
   17.27 + */
   17.28 +
   17.29 +/*
   17.30 + * This file is available under and governed by the GNU General Public
   17.31 + * License version 2 only, as published by the Free Software Foundation.
   17.32 + * However, the following notice accompanied the original version of this
   17.33 + * file, and Oracle licenses the original version of this file under the BSD
   17.34 + * license:
   17.35 + */
   17.36 +/*
   17.37 +   Copyright 2009-2013 Attila Szegedi
   17.38 +
   17.39 +   Licensed under both the Apache License, Version 2.0 (the "Apache License")
   17.40 +   and the BSD License (the "BSD License"), with licensee being free to
   17.41 +   choose either of the two at their discretion.
   17.42 +
   17.43 +   You may not use this file except in compliance with either the Apache
   17.44 +   License or the BSD License.
   17.45 +
   17.46 +   If you choose to use this file in compliance with the Apache License, the
   17.47 +   following notice applies to you:
   17.48 +
   17.49 +       You may obtain a copy of the Apache License at
   17.50 +
   17.51 +           http://www.apache.org/licenses/LICENSE-2.0
   17.52 +
   17.53 +       Unless required by applicable law or agreed to in writing, software
   17.54 +       distributed under the License is distributed on an "AS IS" BASIS,
   17.55 +       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   17.56 +       implied. See the License for the specific language governing
   17.57 +       permissions and limitations under the License.
   17.58 +
   17.59 +   If you choose to use this file in compliance with the BSD License, the
   17.60 +   following notice applies to you:
   17.61 +
   17.62 +       Redistribution and use in source and binary forms, with or without
   17.63 +       modification, are permitted provided that the following conditions are
   17.64 +       met:
   17.65 +       * Redistributions of source code must retain the above copyright
   17.66 +         notice, this list of conditions and the following disclaimer.
   17.67 +       * Redistributions in binary form must reproduce the above copyright
   17.68 +         notice, this list of conditions and the following disclaimer in the
   17.69 +         documentation and/or other materials provided with the distribution.
   17.70 +       * Neither the name of the copyright holder nor the names of
   17.71 +         contributors may be used to endorse or promote products derived from
   17.72 +         this software without specific prior written permission.
   17.73 +
   17.74 +       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   17.75 +       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   17.76 +       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   17.77 +       PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
   17.78 +       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   17.79 +       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   17.80 +       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   17.81 +       BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   17.82 +       WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   17.83 +       OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   17.84 +       ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   17.85 +*/
   17.86 +
   17.87 +package jdk.internal.dynalink.beans;
   17.88 +
   17.89 +import java.lang.invoke.MethodHandle;
   17.90 +import java.lang.invoke.MethodHandles;
   17.91 +import java.lang.invoke.MethodType;
   17.92 +import java.lang.reflect.Array;
   17.93 +import java.util.Collection;
   17.94 +import java.util.List;
   17.95 +import java.util.Map;
   17.96 +import jdk.internal.dynalink.CallSiteDescriptor;
   17.97 +import jdk.internal.dynalink.beans.GuardedInvocationComponent.ValidationType;
   17.98 +import jdk.internal.dynalink.linker.GuardedInvocation;
   17.99 +import jdk.internal.dynalink.linker.LinkerServices;
  17.100 +import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker;
  17.101 +import jdk.internal.dynalink.support.Guards;
  17.102 +import jdk.internal.dynalink.support.Lookup;
  17.103 +import jdk.internal.dynalink.support.TypeUtilities;
  17.104 +
  17.105 +
  17.106 +/**
  17.107 + * A class that provides linking capabilities for a single POJO class. Normally not used directly, but managed by
  17.108 + * {@link BeansLinker}.
  17.109 + *
  17.110 + * @author Attila Szegedi
  17.111 + */
  17.112 +class BeanLinker extends AbstractJavaLinker implements TypeBasedGuardingDynamicLinker {
  17.113 +    BeanLinker(Class<?> clazz) {
  17.114 +        super(clazz, Guards.getClassGuard(clazz), Guards.getInstanceOfGuard(clazz));
  17.115 +        if(clazz.isArray()) {
  17.116 +            // Some languages won't have a notion of manipulating collections. Exposing "length" on arrays as an
  17.117 +            // explicit property is beneficial for them.
  17.118 +            // REVISIT: is it maybe a code smell that "dyn:getLength" is not needed?
  17.119 +            setPropertyGetter("length", GET_ARRAY_LENGTH, ValidationType.IS_ARRAY);
  17.120 +        }
  17.121 +    }
  17.122 +
  17.123 +    @Override
  17.124 +    public boolean canLinkType(Class<?> type) {
  17.125 +        return type == clazz;
  17.126 +    }
  17.127 +
  17.128 +    @Override
  17.129 +    FacetIntrospector createFacetIntrospector() {
  17.130 +        return new BeanIntrospector(clazz);
  17.131 +    }
  17.132 +
  17.133 +    @Override
  17.134 +    protected GuardedInvocationComponent getGuardedInvocationComponent(CallSiteDescriptor callSiteDescriptor,
  17.135 +            LinkerServices linkerServices, List<String> operations) throws Exception {
  17.136 +        final GuardedInvocationComponent superGic = super.getGuardedInvocationComponent(callSiteDescriptor,
  17.137 +                linkerServices, operations);
  17.138 +        if(superGic != null) {
  17.139 +            return superGic;
  17.140 +        }
  17.141 +        if(operations.isEmpty()) {
  17.142 +            return null;
  17.143 +        }
  17.144 +        final String op = operations.get(0);
  17.145 +        // dyn:getElem(this, id)
  17.146 +        // id is typically either an int (for arrays and lists) or an object (for maps). linkerServices can provide
  17.147 +        // conversion from call site argument type though.
  17.148 +        if("getElem".equals(op)) {
  17.149 +            return getElementGetter(callSiteDescriptor, linkerServices, pop(operations));
  17.150 +        }
  17.151 +        if("setElem".equals(op)) {
  17.152 +            return getElementSetter(callSiteDescriptor, linkerServices, pop(operations));
  17.153 +        }
  17.154 +        // dyn:getLength(this) (works on Java arrays, collections, and maps)
  17.155 +        if("getLength".equals(op)) {
  17.156 +            return getLengthGetter(callSiteDescriptor);
  17.157 +        }
  17.158 +        return null;
  17.159 +    }
  17.160 +
  17.161 +    private static MethodHandle GET_LIST_ELEMENT = Lookup.PUBLIC.findVirtual(List.class, "get",
  17.162 +            MethodType.methodType(Object.class, int.class));
  17.163 +
  17.164 +    private static MethodHandle GET_MAP_ELEMENT = Lookup.PUBLIC.findVirtual(Map.class, "get",
  17.165 +            MethodType.methodType(Object.class, Object.class));
  17.166 +
  17.167 +    private static MethodHandle LIST_GUARD = Guards.getInstanceOfGuard(List.class);
  17.168 +    private static MethodHandle MAP_GUARD = Guards.getInstanceOfGuard(Map.class);
  17.169 +
  17.170 +    private GuardedInvocationComponent getElementGetter(final CallSiteDescriptor callSiteDescriptor,
  17.171 +            final LinkerServices linkerServices, List<String> operations) throws Exception {
  17.172 +        final MethodType callSiteType = callSiteDescriptor.getMethodType();
  17.173 +        final Class<?> declaredType = callSiteType.parameterType(0);
  17.174 +        final GuardedInvocationComponent nextComponent = getGuardedInvocationComponent(callSiteDescriptor,
  17.175 +                linkerServices, operations);
  17.176 +
  17.177 +        // If declared type of receiver at the call site is already an array, a list or map, bind without guard. Thing
  17.178 +        // is, it'd be quite stupid of a call site creator to go though invokedynamic when it knows in advance they're
  17.179 +        // dealing with an array, or a list or map, but hey...
  17.180 +        // Note that for arrays and lists, using LinkerServices.asType() will ensure that any language specific linkers
  17.181 +        // in use will get a chance to perform any (if there's any) implicit conversion to integer for the indices.
  17.182 +        final GuardedInvocationComponent gic;;
  17.183 +        final boolean isMap;
  17.184 +        if(declaredType.isArray()) {
  17.185 +            gic = new GuardedInvocationComponent(MethodHandles.arrayElementGetter(declaredType));
  17.186 +            isMap = false;
  17.187 +        } else if(List.class.isAssignableFrom(declaredType)) {
  17.188 +            gic = new GuardedInvocationComponent(GET_LIST_ELEMENT);
  17.189 +            isMap = false;
  17.190 +        } else if(Map.class.isAssignableFrom(declaredType)) {
  17.191 +            gic = new GuardedInvocationComponent(GET_MAP_ELEMENT);
  17.192 +            isMap = true;
  17.193 +        } else if(clazz.isArray()) {
  17.194 +            gic = getClassGuardedInvocationComponent(MethodHandles.arrayElementGetter(clazz), callSiteType);
  17.195 +            isMap = false;
  17.196 +        } else if(List.class.isAssignableFrom(clazz)) {
  17.197 +            gic = new GuardedInvocationComponent(GET_LIST_ELEMENT, Guards.asType(LIST_GUARD, callSiteType), List.class,
  17.198 +                    ValidationType.INSTANCE_OF);
  17.199 +            isMap = false;
  17.200 +        } else if(Map.class.isAssignableFrom(clazz)) {
  17.201 +            gic = new GuardedInvocationComponent(GET_MAP_ELEMENT, Guards.asType(MAP_GUARD, callSiteType), Map.class,
  17.202 +                    ValidationType.INSTANCE_OF);
  17.203 +            isMap = true;
  17.204 +        } else {
  17.205 +            // Can't retrieve elements for objects that are neither arrays, nor list, nor maps.
  17.206 +            return nextComponent;
  17.207 +        }
  17.208 +
  17.209 +        // We can have "dyn:getElem:foo", especially in composites, i.e. "dyn:getElem|getProp|getMethod:foo"
  17.210 +        final String fixedKey = getFixedKey(callSiteDescriptor);
  17.211 +        // Convert the key to a number if we're working with a list or array
  17.212 +        final Object typedFixedKey;
  17.213 +        if(!isMap && fixedKey != null) {
  17.214 +            typedFixedKey = convertKeyToInteger(fixedKey, linkerServices);
  17.215 +            if(typedFixedKey == null) {
  17.216 +                // key is not numeric, it can never succeed
  17.217 +                return nextComponent;
  17.218 +            }
  17.219 +        } else {
  17.220 +            typedFixedKey = fixedKey;
  17.221 +        }
  17.222 +
  17.223 +        final GuardedInvocation gi = gic.getGuardedInvocation();
  17.224 +        final Binder binder = new Binder(linkerServices, callSiteType, typedFixedKey);
  17.225 +        final MethodHandle invocation = gi.getInvocation();
  17.226 +
  17.227 +        if(nextComponent == null) {
  17.228 +            return gic.replaceInvocation(binder.bind(invocation));
  17.229 +        } else {
  17.230 +            final MethodHandle checkGuard;
  17.231 +            if(invocation == GET_LIST_ELEMENT) {
  17.232 +                checkGuard = convertArgToInt(RANGE_CHECK_LIST, linkerServices, callSiteDescriptor);
  17.233 +            } else if(invocation == GET_MAP_ELEMENT) {
  17.234 +                // TODO: A more complex solution could be devised for maps, one where we do a get() first, and fold it
  17.235 +                // into a GWT that tests if it returned null, and if it did, do another GWT with containsKey()
  17.236 +                // that returns constant null (on true), or falls back to next component (on false)
  17.237 +                checkGuard = CONTAINS_MAP;
  17.238 +            } else {
  17.239 +                checkGuard = convertArgToInt(RANGE_CHECK_ARRAY, linkerServices, callSiteDescriptor);
  17.240 +            }
  17.241 +            return nextComponent.compose(MethodHandles.guardWithTest(binder.bindTest(checkGuard),
  17.242 +                    binder.bind(invocation), nextComponent.getGuardedInvocation().getInvocation()), gi.getGuard(),
  17.243 +                    gic.getValidatorClass(), gic.getValidationType());
  17.244 +        }
  17.245 +    }
  17.246 +
  17.247 +    private static String getFixedKey(final CallSiteDescriptor callSiteDescriptor) {
  17.248 +        return callSiteDescriptor.getNameTokenCount() == 2 ? null : callSiteDescriptor.getNameToken(
  17.249 +                CallSiteDescriptor.NAME_OPERAND);
  17.250 +    }
  17.251 +
  17.252 +    private static Object convertKeyToInteger(String fixedKey, LinkerServices linkerServices) throws Exception {
  17.253 +        try {
  17.254 +            if(linkerServices.canConvert(String.class, Number.class)) {
  17.255 +                try {
  17.256 +                    final Object val = linkerServices.getTypeConverter(String.class, Number.class).invoke(fixedKey);
  17.257 +                    if(!(val instanceof Number)) {
  17.258 +                        return null; // not a number
  17.259 +                    }
  17.260 +                    final Number n = (Number)val;
  17.261 +                    if(n instanceof Integer) {
  17.262 +                        return n;
  17.263 +                    }
  17.264 +                    final int intIndex = n.intValue();
  17.265 +                    final double doubleValue = n.doubleValue();
  17.266 +                    if(intIndex != doubleValue && !Double.isInfinite(doubleValue)) { // let infinites trigger IOOBE
  17.267 +                        return null; // not an exact integer
  17.268 +                    }
  17.269 +                    return Integer.valueOf(intIndex);
  17.270 +                } catch(Exception|Error e) {
  17.271 +                    throw e;
  17.272 +                } catch(Throwable t) {
  17.273 +                    throw new RuntimeException(t);
  17.274 +                }
  17.275 +            }
  17.276 +            return Integer.valueOf(fixedKey);
  17.277 +        } catch(NumberFormatException e) {
  17.278 +            // key is not a number
  17.279 +            return null;
  17.280 +        }
  17.281 +    }
  17.282 +
  17.283 +    private static MethodHandle convertArgToInt(MethodHandle mh, LinkerServices ls, CallSiteDescriptor desc) {
  17.284 +        final Class<?> sourceType = desc.getMethodType().parameterType(1);
  17.285 +        if(TypeUtilities.isMethodInvocationConvertible(sourceType, Number.class)) {
  17.286 +            return mh;
  17.287 +        } else if(ls.canConvert(sourceType, Number.class)) {
  17.288 +            final MethodHandle converter = ls.getTypeConverter(sourceType, Number.class);
  17.289 +            return MethodHandles.filterArguments(mh, 1, converter.asType(converter.type().changeReturnType(
  17.290 +                    mh.type().parameterType(1))));
  17.291 +        }
  17.292 +        return mh;
  17.293 +    }
  17.294 +
  17.295 +    /**
  17.296 +     * Contains methods to adapt an item getter/setter method handle to the requested type, optionally binding it to a
  17.297 +     * fixed key first.
  17.298 +     * @author Attila Szegedi
  17.299 +     * @version $Id: $
  17.300 +     */
  17.301 +    private static class Binder {
  17.302 +        private final LinkerServices linkerServices;
  17.303 +        private final MethodType methodType;
  17.304 +        private final Object fixedKey;
  17.305 +
  17.306 +        Binder(LinkerServices linkerServices, MethodType methodType, Object fixedKey) {
  17.307 +            this.linkerServices = linkerServices;
  17.308 +            this.methodType = fixedKey == null ? methodType : methodType.insertParameterTypes(1, fixedKey.getClass());
  17.309 +            this.fixedKey = fixedKey;
  17.310 +        }
  17.311 +
  17.312 +        /*private*/ MethodHandle bind(MethodHandle handle) {
  17.313 +            return bindToFixedKey(linkerServices.asType(handle, methodType));
  17.314 +        }
  17.315 +
  17.316 +        /*private*/ MethodHandle bindTest(MethodHandle handle) {
  17.317 +            return bindToFixedKey(Guards.asType(handle, methodType));
  17.318 +        }
  17.319 +
  17.320 +        private MethodHandle bindToFixedKey(MethodHandle handle) {
  17.321 +            return fixedKey == null ? handle : MethodHandles.insertArguments(handle, 1, fixedKey);
  17.322 +        }
  17.323 +    }
  17.324 +
  17.325 +    private static MethodHandle RANGE_CHECK_ARRAY = findRangeCheck(Object.class);
  17.326 +    private static MethodHandle RANGE_CHECK_LIST = findRangeCheck(List.class);
  17.327 +    private static MethodHandle CONTAINS_MAP = Lookup.PUBLIC.findVirtual(Map.class, "containsKey",
  17.328 +            MethodType.methodType(boolean.class, Object.class));
  17.329 +
  17.330 +    private static MethodHandle findRangeCheck(Class<?> collectionType) {
  17.331 +        return Lookup.findOwnStatic(MethodHandles.lookup(), "rangeCheck", boolean.class, collectionType, Object.class);
  17.332 +    }
  17.333 +
  17.334 +    @SuppressWarnings("unused")
  17.335 +    private static final boolean rangeCheck(Object array, Object index) {
  17.336 +        if(!(index instanceof Number)) {
  17.337 +            return false;
  17.338 +        }
  17.339 +        final Number n = (Number)index;
  17.340 +        final int intIndex = n.intValue();
  17.341 +        final double doubleValue = n.doubleValue();
  17.342 +        if(intIndex != doubleValue && !Double.isInfinite(doubleValue)) { // let infinite trigger IOOBE
  17.343 +            return false;
  17.344 +        }
  17.345 +        if(0 <= intIndex && intIndex < Array.getLength(array)) {
  17.346 +            return true;
  17.347 +        }
  17.348 +        throw new ArrayIndexOutOfBoundsException("Array index out of range: " + n);
  17.349 +    }
  17.350 +
  17.351 +    @SuppressWarnings("unused")
  17.352 +    private static final boolean rangeCheck(List<?> list, Object index) {
  17.353 +        if(!(index instanceof Number)) {
  17.354 +            return false;
  17.355 +        }
  17.356 +        final Number n = (Number)index;
  17.357 +        final int intIndex = n.intValue();
  17.358 +        final double doubleValue = n.doubleValue();
  17.359 +        if(intIndex != doubleValue && !Double.isInfinite(doubleValue)) { // let infinite trigger IOOBE
  17.360 +            return false;
  17.361 +        }
  17.362 +        if(0 <= intIndex && intIndex < list.size()) {
  17.363 +            return true;
  17.364 +        }
  17.365 +        throw new IndexOutOfBoundsException("Index: " + n + ", Size: " + list.size());
  17.366 +    }
  17.367 +
  17.368 +    private static MethodHandle SET_LIST_ELEMENT = Lookup.PUBLIC.findVirtual(List.class, "set",
  17.369 +            MethodType.methodType(Object.class, int.class, Object.class));
  17.370 +
  17.371 +    private static MethodHandle PUT_MAP_ELEMENT = Lookup.PUBLIC.findVirtual(Map.class, "put",
  17.372 +            MethodType.methodType(Object.class, Object.class, Object.class));
  17.373 +
  17.374 +    private GuardedInvocationComponent getElementSetter(CallSiteDescriptor callSiteDescriptor,
  17.375 +            LinkerServices linkerServices, List<String> operations) throws Exception {
  17.376 +        final MethodType callSiteType = callSiteDescriptor.getMethodType();
  17.377 +        final Class<?> declaredType = callSiteType.parameterType(0);
  17.378 +
  17.379 +        final GuardedInvocationComponent gic;
  17.380 +        // If declared type of receiver at the call site is already an array, a list or map, bind without guard. Thing
  17.381 +        // is, it'd be quite stupid of a call site creator to go though invokedynamic when it knows in advance they're
  17.382 +        // dealing with an array, or a list or map, but hey...
  17.383 +        // Note that for arrays and lists, using LinkerServices.asType() will ensure that any language specific linkers
  17.384 +        // in use will get a chance to perform any (if there's any) implicit conversion to integer for the indices.
  17.385 +        final boolean isMap;
  17.386 +        if(declaredType.isArray()) {
  17.387 +            gic = new GuardedInvocationComponent(MethodHandles.arrayElementSetter(declaredType));
  17.388 +            isMap = false;
  17.389 +        } else if(List.class.isAssignableFrom(declaredType)) {
  17.390 +            gic = new GuardedInvocationComponent(SET_LIST_ELEMENT);
  17.391 +            isMap = false;
  17.392 +        } else if(Map.class.isAssignableFrom(declaredType)) {
  17.393 +            gic = new GuardedInvocationComponent(PUT_MAP_ELEMENT);
  17.394 +            isMap = true;
  17.395 +        } else if(clazz.isArray()) {
  17.396 +            gic = getClassGuardedInvocationComponent(MethodHandles.arrayElementSetter(clazz), callSiteType);
  17.397 +            isMap = false;
  17.398 +        } else if(List.class.isAssignableFrom(clazz)) {
  17.399 +            gic = new GuardedInvocationComponent(SET_LIST_ELEMENT, Guards.asType(LIST_GUARD, callSiteType), List.class,
  17.400 +                    ValidationType.INSTANCE_OF);
  17.401 +            isMap = false;
  17.402 +        } else if(Map.class.isAssignableFrom(clazz)) {
  17.403 +            gic = new GuardedInvocationComponent(PUT_MAP_ELEMENT, Guards.asType(MAP_GUARD, callSiteType), Map.class,
  17.404 +                    ValidationType.INSTANCE_OF);
  17.405 +            isMap = true;
  17.406 +        } else {
  17.407 +            // Can't set elements for objects that are neither arrays, nor list, nor maps.
  17.408 +            gic = null;
  17.409 +            isMap = false;
  17.410 +        }
  17.411 +
  17.412 +        // In contrast to, say, getElementGetter, we only compute the nextComponent if the target object is not a map,
  17.413 +        // as maps will always succeed in setting the element and will never need to fall back to the next component
  17.414 +        // operation.
  17.415 +        final GuardedInvocationComponent nextComponent = isMap ? null : getGuardedInvocationComponent(
  17.416 +                callSiteDescriptor, linkerServices, operations);
  17.417 +        if(gic == null) {
  17.418 +            return nextComponent;
  17.419 +        }
  17.420 +
  17.421 +        // We can have "dyn:setElem:foo", especially in composites, i.e. "dyn:setElem|setProp:foo"
  17.422 +        final String fixedKey = getFixedKey(callSiteDescriptor);
  17.423 +        // Convert the key to a number if we're working with a list or array
  17.424 +        final Object typedFixedKey;
  17.425 +        if(!isMap && fixedKey != null) {
  17.426 +            typedFixedKey = convertKeyToInteger(fixedKey, linkerServices);
  17.427 +            if(typedFixedKey == null) {
  17.428 +                // key is not numeric, it can never succeed
  17.429 +                return nextComponent;
  17.430 +            }
  17.431 +        } else {
  17.432 +            typedFixedKey = fixedKey;
  17.433 +        }
  17.434 +
  17.435 +        final GuardedInvocation gi = gic.getGuardedInvocation();
  17.436 +        final Binder binder = new Binder(linkerServices, callSiteType, typedFixedKey);
  17.437 +        final MethodHandle invocation = gi.getInvocation();
  17.438 +
  17.439 +        if(nextComponent == null) {
  17.440 +            return gic.replaceInvocation(binder.bind(invocation));
  17.441 +        } else {
  17.442 +            final MethodHandle checkGuard = convertArgToInt(invocation == SET_LIST_ELEMENT ? RANGE_CHECK_LIST :
  17.443 +                RANGE_CHECK_ARRAY, linkerServices, callSiteDescriptor);
  17.444 +            return nextComponent.compose(MethodHandles.guardWithTest(binder.bindTest(checkGuard),
  17.445 +                    binder.bind(invocation), nextComponent.getGuardedInvocation().getInvocation()), gi.getGuard(),
  17.446 +                    gic.getValidatorClass(), gic.getValidationType());
  17.447 +        }
  17.448 +    }
  17.449 +
  17.450 +    private static MethodHandle GET_ARRAY_LENGTH = Lookup.PUBLIC.findStatic(Array.class, "getLength",
  17.451 +            MethodType.methodType(int.class, Object.class));
  17.452 +
  17.453 +    private static MethodHandle GET_COLLECTION_LENGTH = Lookup.PUBLIC.findVirtual(Collection.class, "size",
  17.454 +            MethodType.methodType(int.class));
  17.455 +
  17.456 +    private static MethodHandle GET_MAP_LENGTH = Lookup.PUBLIC.findVirtual(Map.class, "size",
  17.457 +            MethodType.methodType(int.class));
  17.458 +
  17.459 +    private static MethodHandle COLLECTION_GUARD = Guards.getInstanceOfGuard(Collection.class);
  17.460 +
  17.461 +    private GuardedInvocationComponent getLengthGetter(CallSiteDescriptor callSiteDescriptor) {
  17.462 +        assertParameterCount(callSiteDescriptor, 1);
  17.463 +        final MethodType callSiteType = callSiteDescriptor.getMethodType();
  17.464 +        final Class<?> declaredType = callSiteType.parameterType(0);
  17.465 +        // If declared type of receiver at the call site is already an array, collection, or map, bind without guard.
  17.466 +        // Thing is, it'd be quite stupid of a call site creator to go though invokedynamic when it knows in advance
  17.467 +        // they're dealing with an array, collection, or map, but hey...
  17.468 +        if(declaredType.isArray()) {
  17.469 +            return new GuardedInvocationComponent(GET_ARRAY_LENGTH.asType(callSiteType));
  17.470 +        } else if(Collection.class.isAssignableFrom(declaredType)) {
  17.471 +            return new GuardedInvocationComponent(GET_COLLECTION_LENGTH.asType(callSiteType));
  17.472 +        } else if(Map.class.isAssignableFrom(declaredType)) {
  17.473 +            return new GuardedInvocationComponent(GET_MAP_LENGTH.asType(callSiteType));
  17.474 +        }
  17.475 +
  17.476 +        // Otherwise, create a binding based on the actual type of the argument with an appropriate guard.
  17.477 +        if(clazz.isArray()) {
  17.478 +            return new GuardedInvocationComponent(GET_ARRAY_LENGTH.asType(callSiteType), Guards.isArray(0,
  17.479 +                    callSiteType), ValidationType.IS_ARRAY);
  17.480 +        } if(Collection.class.isAssignableFrom(clazz)) {
  17.481 +            return new GuardedInvocationComponent(GET_COLLECTION_LENGTH.asType(callSiteType), Guards.asType(
  17.482 +                    COLLECTION_GUARD, callSiteType), Collection.class, ValidationType.INSTANCE_OF);
  17.483 +        } if(Map.class.isAssignableFrom(clazz)) {
  17.484 +            return new GuardedInvocationComponent(GET_MAP_LENGTH.asType(callSiteType), Guards.asType(MAP_GUARD,
  17.485 +                    callSiteType), Map.class, ValidationType.INSTANCE_OF);
  17.486 +        }
  17.487 +        // Can't retrieve length for objects that are neither arrays, nor collections, nor maps.
  17.488 +        return null;
  17.489 +    }
  17.490 +
  17.491 +    private static void assertParameterCount(CallSiteDescriptor descriptor, int paramCount) {
  17.492 +        if(descriptor.getMethodType().parameterCount() != paramCount) {
  17.493 +            throw new BootstrapMethodError(descriptor.getName() + " must have exactly " + paramCount + " parameters.");
  17.494 +        }
  17.495 +    }
  17.496 +}
  17.497 \ No newline at end of file