-----
 Hervé Boutemy
 -----
 2012-06-02
 -----

Maven 3 Plugin API

 The API for Maven 3 plugins - composed of goals implemented by Mojos - development:

 * goal code extends {{{./apidocs/org/apache/maven/plugin/AbstractMojo.html}<<<AbstractMojo>>> base class}} that implements {{{./apidocs/org/apache/maven/plugin/Mojo.html}<<<Mojo>>> interface}},

@Experimental
@Generated @ThreadSafe @Immutable
public class ${class.name}
    #if ( $class.superClass )
    extends ${class.superClass}
    #end
    #if ( $locationTracking )
    implements Serializable, InputLocationTracker
    #else
    implements Serializable
    #end
{
    #if ( $class == $root )
    final String namespaceUri;
    final String modelEncoding;
    #end

 * creation of an analysis session, and disposed after the analysis session has been invalidated.
 *
 * [KaResolveExtension] implements the [Disposable] interface. The resolve extension can then act as a parent disposable, e.g. for a message
 * bus connection.
 *
 * You *must not* implement [KaResolveExtension]s as module-level services, due to the following reasons:
 *

     {{{http://slf4j.org/apidocs/org/slf4j/Logger.html}Logger}},

  *  instead of implementing Plexus logging API itself with basic output to console, Maven implements it using SLF4J API in
     {{{./apidocs/org/apache/maven/cli/logging/Slf4jLoggerManager.html}Slf4jLoggerManager}}
     / {{{./apidocs/org/apache/maven/cli/logging/Slf4jLogger.html}Slf4jLogger}}.


* Logging Implementation

package ${package};

  #foreach ( $imp in $imports )
import $imp;
  #end

@Generated
public class ${class.name}
    #if ( $class.superClass )
    extends ${class.superClass}
    implements Serializable, Cloneable
    #else
    extends BaseObject
    #end
{

    public ${class.name}() {
        this(${packageModelV4}.${class.name}.newInstance());
    }

     * // SuperInterface.java
     * public interface SuperInterface {
     *     public static void fromSuperInterface() { }
     * }
     *
     * // SuperClass.java
     * public abstract class SuperClass implements SuperInterface {
     *     static class NestedSuperClass { }
     *     class InnerSuperClass { }
     *     public static void fromSuperClass() { }
     * }
     *
     * // FILE: JavaClass.java

import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name

/**
 * Implements [KaNamedClassOrObjectSymbol] for a Java class. The underlying [firSymbol] is built lazily and only when needed. Many simple

        list.mergeAll(src, remapping);
        return list;
    }

    /**
     * Merging list
     * @param <V>
     */
    private static class MergingList<V> extends AbstractList<V> implements java.io.Serializable {

        private final KeyComputer<V> keyComputer;
        private Map<Object, V> map;
        private List<V> list;

        MergingList(KeyComputer<V> keyComputer, int initialCapacity) {

    override fun getExitPointSnapshot(statements: List<KtExpression>): KaDataFlowExitPointSnapshot {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeOwner
import org.jetbrains.kotlin.name.ClassId

/**
 * A list of annotations applied for some entity.
 *
 * Annotation owners are usually implement [KaAnnotated]
 */
public interface KaAnnotationList : List<KaAnnotation>, KaLifetimeOwner {
    @Deprecated("Use the annotation list as a 'List'.")
    public val annotations: List<KaAnnotation>
        get() = this