
/*
 * Janino - An embedded Java[TM] compiler
 *
 * Copyright (c) 2001-2010 Arno Unkrig. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
 *       following disclaimer.
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
 *       following disclaimer in the documentation and/or other materials provided with the distribution.
 *    3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
 *       products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.codehaus.janino;

import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.codehaus.commons.compiler.CompileException;
import org.codehaus.commons.compiler.InternalCompilerException;
import org.codehaus.commons.compiler.util.StringUtil;
import org.codehaus.commons.compiler.util.resource.JarDirectoriesResourceFinder;
import org.codehaus.commons.compiler.util.resource.PathResourceFinder;
import org.codehaus.commons.compiler.util.resource.ResourceFinder;
import org.codehaus.commons.nullanalysis.Nullable;
import org.codehaus.janino.IClass.IConstructor;
import org.codehaus.janino.IClass.IMethod;

/**
 * Loads an {@link IClass} by type name.
 */
public abstract
class IClassLoader {

    private static final Logger LOGGER = Logger.getLogger(IClassLoader.class.getName());

    // The following are constants, but cannot be declared FINAL, because they are only initialized by
    // "postConstruct()".

    // SUPPRESS CHECKSTYLE MemberName|AbbreviationAsWordInName|JavadocVariable:57

    // Representations of commonly used classes.
    public IClass TYPE_java_lang_annotation_Retention;
    public IClass TYPE_java_lang_AssertionError;
    public IClass TYPE_java_lang_Boolean;
    public IClass TYPE_java_lang_Byte;
    public IClass TYPE_java_lang_Character;
    public IClass TYPE_java_lang_Class;
    public IClass TYPE_java_lang_Cloneable;
    public IClass TYPE_java_lang_Double;
    public IClass TYPE_java_lang_Enum;
    public IClass TYPE_java_lang_Error;
    public IClass TYPE_java_lang_Exception;
    public IClass TYPE_java_lang_Float;
    public IClass TYPE_java_lang_Integer;
    public IClass TYPE_java_lang_Iterable;
    public IClass TYPE_java_lang_Long;
    public IClass TYPE_java_lang_Object;
    public IClass TYPE_java_lang_Override;
    public IClass TYPE_java_lang_RuntimeException;
    public IClass TYPE_java_lang_Short;
    public IClass TYPE_java_lang_String;
    public IClass TYPE_java_lang_StringBuilder;
    public IClass TYPE_java_lang_System;
    public IClass TYPE_java_lang_Throwable;
    public IClass TYPE_java_lang_Void;
    public IClass TYPE_java_io_Serializable;
    public IClass TYPE_java_util_Iterator;

    // Representations of commonly used methods.
    public IMethod           METH_java_lang_Enum__ordinal;
    public IMethod           METH_java_lang_Iterable__iterator;
    public IMethod           METH_java_lang_String__concat__java_lang_String;
    public IMethod           METH_java_lang_String__equals__java_lang_Object;
    public IMethod           METH_java_lang_String__hashCode;
    public IMethod           METH_java_lang_String__valueOf__int;
    public IMethod           METH_java_lang_String__valueOf__long;
    public IMethod           METH_java_lang_String__valueOf__float;
    public IMethod           METH_java_lang_String__valueOf__double;
    public IMethod           METH_java_lang_String__valueOf__char;
    public IMethod           METH_java_lang_String__valueOf__boolean;
    public IMethod           METH_java_lang_String__valueOf__java_lang_Object;
    public IMethod           METH_java_lang_StringBuilder__append__int;
    public IMethod           METH_java_lang_StringBuilder__append__long;
    public IMethod           METH_java_lang_StringBuilder__append__float;
    public IMethod           METH_java_lang_StringBuilder__append__double;
    public IMethod           METH_java_lang_StringBuilder__append__char;
    public IMethod           METH_java_lang_StringBuilder__append__boolean;
    public IMethod           METH_java_lang_StringBuilder__append__java_lang_Object;
    public IMethod           METH_java_lang_StringBuilder__append__java_lang_String;
    public IMethod           METH_java_lang_StringBuilder__toString;
    @Nullable public IMethod METH_java_lang_Throwable__addSuppressed;
    public IMethod           METH_java_util_Iterator__hasNext;
    public IMethod           METH_java_util_Iterator__next;

    // Representations of commonly used constructors.
    public IConstructor CTOR_java_lang_StringBuilder__java_lang_String;

    /**
     * @param parentIClassLoader {@code null} iff this {@link IClassLoader} has no parent
     */
    @SuppressWarnings("null") public
    IClassLoader(@Nullable IClassLoader parentIClassLoader) {
        this.parentIClassLoader = parentIClassLoader;
    }

    public IClassLoader
    getParentIClassLoader() { return this.parentIClassLoader; }

    /**
     * This method must be called by the constructor of the <em>derived</em> class. (The reason being is that this
     * method invokes abstract {@link #loadIClass(String)} which will not work until the derived class is constructed.)
     */
    protected final void
    postConstruct() {
        try {
            this.TYPE_java_lang_annotation_Retention = this.requireType(Descriptor.JAVA_LANG_ANNOTATION_RETENTION);
            this.TYPE_java_lang_AssertionError       = this.requireType(Descriptor.JAVA_LANG_ASSERTIONERROR);
            this.TYPE_java_lang_Boolean              = this.requireType(Descriptor.JAVA_LANG_BOOLEAN);
            this.TYPE_java_lang_Byte                 = this.requireType(Descriptor.JAVA_LANG_BYTE);
            this.TYPE_java_lang_Character            = this.requireType(Descriptor.JAVA_LANG_CHARACTER);
            this.TYPE_java_lang_Class                = this.requireType(Descriptor.JAVA_LANG_CLASS);
            this.TYPE_java_lang_Cloneable            = this.requireType(Descriptor.JAVA_LANG_CLONEABLE);
            this.TYPE_java_lang_Double               = this.requireType(Descriptor.JAVA_LANG_DOUBLE);
            this.TYPE_java_lang_Enum                 = this.requireType(Descriptor.JAVA_LANG_ENUM);
            this.TYPE_java_lang_Error                = this.requireType(Descriptor.JAVA_LANG_ERROR);
            this.TYPE_java_lang_Exception            = this.requireType(Descriptor.JAVA_LANG_EXCEPTION);
            this.TYPE_java_lang_Float                = this.requireType(Descriptor.JAVA_LANG_FLOAT);
            this.TYPE_java_lang_Integer              = this.requireType(Descriptor.JAVA_LANG_INTEGER);
            this.TYPE_java_lang_Iterable             = this.requireType(Descriptor.JAVA_LANG_ITERABLE);
            this.TYPE_java_lang_Long                 = this.requireType(Descriptor.JAVA_LANG_LONG);
            this.TYPE_java_lang_Object               = this.requireType(Descriptor.JAVA_LANG_OBJECT);
            this.TYPE_java_lang_Override             = this.requireType(Descriptor.JAVA_LANG_OVERRIDE);
            this.TYPE_java_lang_RuntimeException     = this.requireType(Descriptor.JAVA_LANG_RUNTIMEEXCEPTION);
            this.TYPE_java_lang_Short                = this.requireType(Descriptor.JAVA_LANG_SHORT);
            this.TYPE_java_lang_String               = this.requireType(Descriptor.JAVA_LANG_STRING);
            this.TYPE_java_lang_StringBuilder        = this.requireType(Descriptor.JAVA_LANG_STRINGBUILDER);
            this.TYPE_java_lang_System               = this.requireType(Descriptor.JAVA_LANG_SYSTEM);
            this.TYPE_java_lang_Throwable            = this.requireType(Descriptor.JAVA_LANG_THROWABLE);
            this.TYPE_java_lang_Void                 = this.requireType(Descriptor.JAVA_LANG_VOID);
            this.TYPE_java_io_Serializable           = this.requireType(Descriptor.JAVA_IO_SERIALIZABLE);
            this.TYPE_java_util_Iterator             = this.requireType(Descriptor.JAVA_UTIL_ITERATOR);

            this.METH_java_lang_Enum__ordinal                           = IClassLoader.requireMethod(this.TYPE_java_lang_Enum,          "ordinal");
            this.METH_java_lang_Iterable__iterator                      = IClassLoader.requireMethod(this.TYPE_java_lang_Iterable,      "iterator");
            this.METH_java_lang_String__concat__java_lang_String        = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "concat",   this.TYPE_java_lang_String);
            this.METH_java_lang_String__equals__java_lang_Object        = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "equals",   this.TYPE_java_lang_Object);
            this.METH_java_lang_String__hashCode                        = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "hashCode");
            this.METH_java_lang_String__valueOf__int                    = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  IClass.INT);
            this.METH_java_lang_String__valueOf__long                   = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  IClass.LONG);
            this.METH_java_lang_String__valueOf__float                  = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  IClass.FLOAT);
            this.METH_java_lang_String__valueOf__double                 = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  IClass.DOUBLE);
            this.METH_java_lang_String__valueOf__char                   = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  IClass.CHAR);
            this.METH_java_lang_String__valueOf__boolean                = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  IClass.BOOLEAN);
            this.METH_java_lang_String__valueOf__java_lang_Object       = IClassLoader.requireMethod(this.TYPE_java_lang_String,        "valueOf",  this.TYPE_java_lang_Object);
            this.METH_java_lang_StringBuilder__append__int              = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   IClass.INT);
            this.METH_java_lang_StringBuilder__append__long             = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   IClass.LONG);
            this.METH_java_lang_StringBuilder__append__float            = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   IClass.FLOAT);
            this.METH_java_lang_StringBuilder__append__double           = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   IClass.DOUBLE);
            this.METH_java_lang_StringBuilder__append__char             = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   IClass.CHAR);
            this.METH_java_lang_StringBuilder__append__boolean          = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   IClass.BOOLEAN);
            this.METH_java_lang_StringBuilder__append__java_lang_Object = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   this.TYPE_java_lang_Object);
            this.METH_java_lang_StringBuilder__append__java_lang_String = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "append",   this.TYPE_java_lang_String);
            this.METH_java_lang_StringBuilder__toString                 = IClassLoader.requireMethod(this.TYPE_java_lang_StringBuilder, "toString");
            this.METH_java_lang_Throwable__addSuppressed                = IClassLoader.getMethod(this.TYPE_java_lang_Throwable, "addSuppressed", this.TYPE_java_lang_Throwable);
            this.METH_java_util_Iterator__hasNext                       = IClassLoader.requireMethod(this.TYPE_java_util_Iterator,      "hasNext");
            this.METH_java_util_Iterator__next                          = IClassLoader.requireMethod(this.TYPE_java_util_Iterator,      "next");

            this.CTOR_java_lang_StringBuilder__java_lang_String = IClassLoader.requireConstructor(this.TYPE_java_lang_StringBuilder, this.TYPE_java_lang_String);

        } catch (Exception e) {
            throw new InternalCompilerException("Cannot load simple types", e);
        }
    }

    private IClass
    requireType(String descriptor) {

        IClass result;
        try {
            result = this.loadIClass(descriptor);
        } catch (ClassNotFoundException cnfe) {
            throw new AssertionError(cnfe);
        }

        if (result != null) return result;

        throw new AssertionError("Required type \"" + descriptor + "\" not found");
    }

    /**
     * @return {@code null} iff the <var>declaringType</var> does not declare a method with that name and parameter
     *         types
     */
    @Nullable private static IMethod
    getMethod(IClass declaringType, String name, IClass... parameterTypes) {

        try {
            return declaringType.findIMethod(name, parameterTypes);
        } catch (CompileException ce) {
            throw new AssertionError(ce);
        }
    }

    /**
     * @throws AssertionError The <var>declaringType</var> does not declare a method with that name and parameter
     *         types
     */
    private static IMethod
    requireMethod(IClass declaringType, String name, IClass... parameterTypes) {

        IMethod result = IClassLoader.getMethod(declaringType, name, parameterTypes);

        if (result == null) {
            throw new AssertionError("Required method \"" + name + "\" not found in \"" + declaringType + "\"");
        }

        return result;
    }

    private static IConstructor
    requireConstructor(IClass declaringType, IClass... parameterTypes) {

        IConstructor result;
        try {
            result = declaringType.findIConstructor(parameterTypes);
        } catch (CompileException ce) {
            throw new AssertionError(ce);
        }

        if (result != null) return result;

        throw new AssertionError("Required constructor not found in \"" + declaringType + "\"");
    }

    /**
     * Gets an {@link IClass} by field descriptor.
     *
     * @param fieldDescriptor         E.g. 'Lpkg1/pkg2/Outer$Inner;'
     * @return                        {@code null} if an {@link IClass} could not be loaded
     * @throws ClassNotFoundException An exception was raised while loading the {@link IClass}
     */
    @Nullable public final IClass
    loadIClass(String fieldDescriptor) throws ClassNotFoundException {
        IClassLoader.LOGGER.entering(null, "loadIClass", fieldDescriptor);

        if (Descriptor.isPrimitive(fieldDescriptor)) {
            return (
                fieldDescriptor.equals(Descriptor.VOID)    ? IClass.VOID :
                fieldDescriptor.equals(Descriptor.BYTE)    ? IClass.BYTE :
                fieldDescriptor.equals(Descriptor.CHAR)    ? IClass.CHAR :
                fieldDescriptor.equals(Descriptor.DOUBLE)  ? IClass.DOUBLE :
                fieldDescriptor.equals(Descriptor.FLOAT)   ? IClass.FLOAT :
                fieldDescriptor.equals(Descriptor.INT)     ? IClass.INT :
                fieldDescriptor.equals(Descriptor.LONG)    ? IClass.LONG :
                fieldDescriptor.equals(Descriptor.SHORT)   ? IClass.SHORT :
                fieldDescriptor.equals(Descriptor.BOOLEAN) ? IClass.BOOLEAN :
                null
            );
        }

        // Ask parent IClassLoader first.
        @SuppressWarnings("null") boolean hasParentIClassLoader = this.parentIClassLoader != null;
        if (hasParentIClassLoader) {
            IClass res = this.parentIClassLoader.loadIClass(fieldDescriptor);
            if (res != null) return res;
        }

        // We need to synchronize here because "unloadableIClasses" and "loadedIClasses" are unsynchronized
        // containers. Also, "findIClass()" is not thread safe.
        IClass result;

        synchronized (this) {

            // Class could not be loaded before?
            if (this.unloadableIClasses.contains(fieldDescriptor)) return null;

            // Class already loaded?
            result = (IClass) this.loadedIClasses.get(fieldDescriptor);
            if (result != null) return result;

            // Special handling for array types.
            if (Descriptor.isArrayReference(fieldDescriptor)) {

                // Load the component type.
                IClass componentIClass = this.loadIClass(
                    Descriptor.getComponentDescriptor(fieldDescriptor)
                );
                if (componentIClass == null) return null;

                // Now get and define the array type.
                IClass arrayIClass = this.getArrayIClass(componentIClass);
                this.loadedIClasses.put(fieldDescriptor, arrayIClass);
                return arrayIClass;
            }

            // Load the class through the {@link #findIClass(String)} method implemented by the derived class.
            // By contract, {@link findIClass(String)} <em>must</em> invoke {@link #defineIClass(IClass)}!
            IClassLoader.LOGGER.log(Level.FINE, "About to call \"findIClass({0})\"", fieldDescriptor);
            result = this.findIClass(fieldDescriptor);
            if (result == null) {
                if (this.loadedIClasses.containsKey(fieldDescriptor)) {
                    throw new InternalCompilerException((
                        "\"findIClass(\""
                        + fieldDescriptor
                        + "\")\" called \"defineIClass()\", but returned null!?"
                    ));
                }
                this.unloadableIClasses.add(fieldDescriptor);
                return null;
            }
            if (!this.loadedIClasses.containsKey(fieldDescriptor)) {
                throw new InternalCompilerException((
                    "\"findIClass(\""
                    + fieldDescriptor
                    + "\")\" did not call \"defineIClass()\"!?"
                ));
            }
        }

        if (!result.getDescriptor().equalsIgnoreCase(fieldDescriptor)) {
            throw new InternalCompilerException(
                "\"findIClass()\" returned \""
                + result.getDescriptor()
                + "\" instead of \""
                + fieldDescriptor
                + "\""
            );
        }

        IClassLoader.LOGGER.exiting(null, "loadIClass", result);
        return result;
    }

    /**
     * Finds a new {@link IClass} by descriptor and calls {@link #defineIClass(IClass)}.
     * <p>
     *   Similar {@link java.lang.ClassLoader#findClass(java.lang.String)}, this method must
     * </p>
     * <ul>
     *   <li>Get an {@link IClass} object from somewhere for the given type</li>
     *   <li>Call {@link #defineIClass(IClass)} with that {@link IClass} object as the argument</li>
     *   <li>Return the {@link IClass} object</li>
     * </ul>
     * <p>
     *   The format of a {@code descriptor} is defined in JVMS 4.3.2. Typical descriptors are:
     * </p>
     * <ul>
     *   <li>{@code I} (Integer)</li>
     *   <li>{@code Lpkg1/pkg2/Clazz;} (Class declared in package)</li>
     *   <li>{@code Lpkg1/pkg2/Outer$Inner;} Member class</li>
     * </ul>
     * <p>
     *   Notice that this method is never called for array types.
     * </p>
     * <p>
     *   Notice that this method is never called from more than one thread at a time. In other words, implementations
     *   of this method need not be thread-safe.
     * </p>
     *
     * @return                        {@code null} if a class with that descriptor could not be found
     * @throws ClassNotFoundException An exception was raised while loading the class
     */
    @Nullable protected abstract IClass
    findIClass(String descriptor) throws ClassNotFoundException;

    /**
     * Defines an {@link IClass} in the context of this {@link IClassLoader}.
     * <p>
     *   This method should only be called from an implementation of {@link #findIClass(String)}.
     * </p>
     *
     * @throws InternalCompilerException A different {@link IClass} object is already defined for this type
     */
    protected final void
    defineIClass(IClass iClass) {
        String descriptor = iClass.getDescriptor();
        IClassLoader.LOGGER.log(Level.FINE, "{0}: Defined type \"{0}\"", descriptor);

        // Define.
        IClass prev = (IClass) this.loadedIClasses.put(descriptor, iClass);

        // Previously defined?
        if (prev != null) {
            throw new InternalCompilerException("Non-identical definition of IClass \"" + descriptor + "\"");
        }
    }

    /**
     * Gets an {@link IClass} that represents an n-dimensional array of this type.
     *
     * @param componentType Required because the superclass of an array class is {@link Object} by definition
     * @param n             Dimension count
     */
    public IClass
    getArrayIClass(IClass componentType, int n) {
        IClass result = componentType;
        for (int i = 0; i < n; ++i) result = this.getArrayIClass(result);
        return result;
    }

    /**
     * Gets an {@link IClass} that represents an array of this type.
     *
     * @param componentType Required because the superclass of an array class is {@link Object} by definition
     */
    public synchronized IClass
    getArrayIClass(IClass componentType) {

        if (this.parentIClassLoader != null) return this.parentIClassLoader.getArrayIClass(componentType);

        IClass result = (IClass) this.arrayIClasses.get(componentType);
        if (result != null) return result;

        this.arrayIClasses.put(componentType, (result = this.getArrayIClass2(componentType)));
        return result;
    }
    private final Map<IClass, IClass> arrayIClasses = new HashMap<>();

    /**
     * @param objectType Must pass {@link IClassLoader#TYPE_java_lang_Object} here
     */
    private IClass
    getArrayIClass2(final IClass componentType) {

        return new IClass() {

            @Override protected ITypeVariable[]    getITypeVariables2()        { return new ITypeVariable[0];       }
            @Override public IClass.IConstructor[] getDeclaredIConstructors2() { return new IClass.IConstructor[0]; }

            // Special trickery #17: Arrays override "Object.clone()", but without "throws
            // CloneNotSupportedException"!
            @Override public IClass.IMethod[]
            getDeclaredIMethods2() {
                return new IClass.IMethod[] {
                    new IMethod() {
                        @Override public IAnnotation[] getAnnotations()       { return new IAnnotation[0];                      }
                        @Override public Access        getAccess()            { return Access.PUBLIC;                           }
                        @Override public boolean       isStatic()             { return false;                                   }
                        @Override public boolean       isAbstract()           { return false;                                   }
                        @Override public IClass        getReturnType()        { return IClassLoader.this.TYPE_java_lang_Object; }
                        @Override public String        getName()              { return "clone";                                 }
                        @Override public IClass[]      getParameterTypes2()   { return new IClass[0];                           }
                        @Override public boolean       isVarargs()            { return false;                                   }
                        @Override public IClass[]      getThrownExceptions2() { return new IClass[0];                           }
                    }
                };
            }

            @Override public IClass.IField[]  getDeclaredIFields2()  { return new IClass.IField[0];                    }
            @Override public IClass[]         getDeclaredIClasses2() { return new IClass[0];                           }
            @Override @Nullable public IClass getDeclaringIClass2()  { return null;                                    }
            @Override @Nullable public IClass getOuterIClass2()      { return null;                                    }
            @Override public IClass           getSuperclass2()       { return IClassLoader.this.TYPE_java_lang_Object; }
            @Override public IClass[]         getInterfaces2()       { return new IClass[0];                           }
            @Override public String           getDescriptor2()       { return '[' + componentType.getDescriptor();     }
            @Override public Access           getAccess()            { return componentType.getAccess();               }
            @Override public boolean          isFinal()              { return true;                                    }
            @Override public boolean          isEnum()               { return false;                                   }
            @Override public boolean          isInterface()          { return false;                                   }
            @Override public boolean          isAbstract()           { return false;                                   }
            @Override public boolean          isArray()              { return true;                                    }
            @Override public boolean          isPrimitive()          { return false;                                   }
            @Override public boolean          isPrimitiveNumeric()   { return false;                                   }
            @Override public IClass           getComponentType2()    { return componentType;                           }

            @Override public String toString() { return componentType.toString() + "[]"; }
        };
    }

    /**
     * Creates an {@link IClassLoader} that looks for classes in the given "boot class path", then in the given
     * "extension directories", and then in the given "class path".
     * <p>
     *   The default for the {@code bootClassPath} is the path defined in the system property
     *   "sun.boot.class.path", and the default for the {@code extensionDirs} is the path defined in the
     *   "java.ext.dirs" system property.
     * </p>
     */
    public static IClassLoader
    createJavacLikePathIClassLoader(
        @Nullable final File[] bootClassPath,
        @Nullable final File[] extDirs,
        final File[]           classPath
    ) {
        ResourceFinder bootClassPathResourceFinder = new PathResourceFinder(
            bootClassPath == null
            ? StringUtil.parsePath(System.getProperty("sun.boot.class.path"))
            : bootClassPath
        );
        ResourceFinder extensionDirectoriesResourceFinder = new JarDirectoriesResourceFinder(
            extDirs == null
            ? StringUtil.parsePath(System.getProperty("java.ext.dirs"))
            : extDirs
        );
        final ResourceFinder classPathResourceFinder = new PathResourceFinder(classPath);

        // We can load classes through "ResourceFinderIClassLoader"s, which means
        // they are read into "ClassFile" objects, or we can load classes through
        // "ClassLoaderIClassLoader"s, which means they are loaded into the JVM.
        //
        // In my environment, the latter is slightly faster. No figures about
        // resource usage yet.
        //
        // In applications where the generated classes are not loaded into the
        // same JVM instance, we should avoid to use the
        // ClassLoaderIClassLoader, because that assumes that final fields have
        // a constant value, even if not compile-time-constant but only
        // initialization-time constant. The classical example is
        // "File.separator", which is non-blank final, but not compile-time-
        // constant.
        IClassLoader icl;
        icl = new ResourceFinderIClassLoader(bootClassPathResourceFinder, null);
        icl = new ResourceFinderIClassLoader(extensionDirectoriesResourceFinder, icl);
        icl = new ResourceFinderIClassLoader(classPathResourceFinder, icl);
        return icl;
    }

    private final IClassLoader                       parentIClassLoader;
    private final Map<String /*descriptor*/, IClass> loadedIClasses     = new HashMap<>();
    private final Set<String /*descriptor*/>         unloadableIClasses = new HashSet<>();
}
