groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sun...@apache.org
Subject [08/47] groovy git commit: Move source files to proper packages
Date Wed, 20 Dec 2017 04:29:16 GMT
http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/IndexedProperty.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/IndexedProperty.java b/src/main/groovy/transform/IndexedProperty.java
deleted file mode 100644
index cf77d98..0000000
--- a/src/main/groovy/transform/IndexedProperty.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Field annotation used with properties to provide an indexed getter and setter for the property.
- * Groovy provides nice GPath syntax support for accessing indexed properties but Java tools
- * or frameworks may expect the JavaBean style setters and getters.
- * <p>
- * <em>Example usage:</em> suppose you have a class with the following properties:
- * <pre>
- * {@code @IndexedProperty} FieldType[] someField
- * {@code @IndexedProperty} List<FieldType> otherField
- * {@code @IndexedProperty} List furtherField
- * </pre>
- * will add the following methods to the class containing the properties:
- * <pre>
- * FieldType getSomeField(int index) {
- *     someField[index]
- * }
- * FieldType getOtherField(int index) {
- *     otherField[index]
- * }
- * Object getFurtherField(int index) {
- *     furtherField[index]
- * }
- * void setSomeField(int index, FieldType val) {
- *     someField[index] = val
- * }
- * void setOtherField(int index, FieldType val) {
- *     otherField[index] = val
- * }
- * void setFurtherField(int index, Object val) {
- *     furtherField[index] = val
- * }
- * </pre>
- * Normal Groovy visibility rules for properties apply
- * (i.e. no <code>public</code>, <code>private</code> or <code>package</code>
- * visibility can be specified) or you will receive a compile-time error message.
- * The normal Groovy property getters and setters will also be created.
- * <p>
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * import groovy.transform.IndexedProperty
- *
- * class Group {
- *     String name
- *     List members = []
- * }
- *
- * class IndexedGroup {
- *     String name
- *     &#64;IndexedProperty List members = []
- * }
- *
- * def group = new Group(name: 'Groovy')
- * group.members[0] = 'mrhaki'
- * group.members[1] = 'Hubert'
- * assert 2 == group.members.size()
- * assert ['mrhaki', 'Hubert'] == group.members
- *
- * try {
- *     group.setMembers(0, 'hubert') // Not index property
- * } catch (MissingMethodException e) {
- *     assert e
- * }
- *
- * def indexedGroup = new IndexedGroup(name: 'Grails')
- * indexedGroup.members[0] = 'mrhaki'
- * indexedGroup.setMembers 1, 'Hubert'
- * assert 2 == indexedGroup.members.size()
- * assert 'mrhaki' == indexedGroup.getMembers(0)
- * assert 'Hubert' == indexedGroup.members[1]
- * </pre>
- *
- * @author Paul King
- * @since 1.7.3
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.FIELD})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.IndexedPropertyASTTransformation")
-public @interface IndexedProperty {
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/InheritConstructors.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/InheritConstructors.java b/src/main/groovy/transform/InheritConstructors.java
deleted file mode 100644
index f4c77f5..0000000
--- a/src/main/groovy/transform/InheritConstructors.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Class annotation to make constructors from a super class available in a sub class.
- * Should be used with care with other annotations which create constructors - see "Known
- * Limitations" for more details.
- * <p>
- * {@code @InheritConstructors} saves you typing some boilerplate code.
- * <p>
- * <em>Example usage:</em>
- * <pre class="groovyTestCase">
- * class Person {
- *     String first, last
- *     Person(String first, String last) {
- *         this.first = first
- *         this.last = last.toUpperCase()
- *     }
- * }
- *
- * {@code @groovy.transform.InheritConstructors}
- * class PersonAge extends Person {
- *     int age
- * }
- *
- * def js = new PersonAge('John', 'Smith')
- * js.age = 25
- * 
- * assert "$js.last, $js.first is $js.age years old" == 'SMITH, John is 25 years old'
- * </pre>
- * for this case, the <code>PersonAge</code> class will be
- * equivalent to the following code:
- * <pre>
- * class PersonAge extends Person {
- *     PersonAge(String first, String last) {
- *         super(first, last)
- *     }
- *     int age
- * }
- * </pre>
- * You may add additional constructors in addition to inherited ones.
- * If the argument types of a supplied constructor exactly match those
- * of a parent constructor, then that constructor won't be inherited.
- * <p>
- * <em>Style note:</em> Don't go overboard using this annotation.
- * Typical Groovy style is to use named-arg constructors when possible.
- * This is easy to do for Groovy objects or any objects following JavaBean
- * conventions. In other cases, inheriting the constructors may be useful.
- * However, sub-classes often introduce new properties and these are often best
- * set in a constructor; especially if that matches the style adopted
- * in parent classes. So, even for the example above, it may have been
- * better style to define an explicit constructor for <code>PersonAge</code>
- * that also set the <code>age</code> property. Sometimes, consistent
- * style is much more important than saving a few keystrokes.
- * <p>
- * As another example, this:
- * <pre>
- * {@code @InheritConstructors} class CustomException extends RuntimeException { }
- * </pre>
- * is equivalent to this:
- * <pre>
- * class CustomException extends RuntimeException {
- *     CustomException() {
- *         super()
- *     }
- *     CustomException(String message) {
- *         super(message)
- *     }
- *     CustomException(String message, Throwable cause) {
- *         super(message, cause)
- *     }
- *     CustomException(Throwable cause) {
- *         super(cause)
- *     }
- * }
- * </pre>
- * Known Limitations:
- * <ul>
- * <li>This AST transform creates (potentially) numerous constructors.
- * You should take care to avoid constructors with duplicate signatures if you are defining your own constructors or
- * combining with other AST transforms which create constructors (e.g. {@code @TupleConstructor});
- * the order in which the particular transforms are processed becomes important in that case.</li>
- * <li>If you create Groovy constructors with optional
- * arguments this leads to multiple constructors created in the byte code.
- * The expansion to multiple constructors occurs in a later phase to
- * this AST transformation. This means that you can't override (i.e. not
- * inherit) the constructors with signatures that Groovy adds later.
- * If you get it wrong you will get a compile-time error about the duplication.</li>
- * </ul>
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * import groovy.transform.InheritConstructors
- *
- * &#64;InheritConstructors
- * class MyException extends Exception {
- * }
- *
- * def e = new MyException()
- * def e1 = new MyException('message')   // Other constructors are available.
- * assert 'message' == e1.message
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * import groovy.transform.InheritConstructors
-
- * class Person {
- *     String name
- *
- *     Person(String name) {
- *         this.name = name
- *     }
- * }
- *
- * &#64;InheritConstructors
- * class Child extends Person {}
- *
- * def child = new Child('Liam')
- * assert 'Liam' == child.name
- * </pre>
- *
- * @author Paul King
- * @since 1.7.3
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.TYPE})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.InheritConstructorsASTTransformation")
-public @interface InheritConstructors {
-    /**
-     * Whether to carry over annotations on the copied constructors.
-     * Currently Closure annotation members are not supported.
-     *
-     * @return true if copied constructor should keep constructor annotations
-     */
-    boolean constructorAnnotations() default false;
-
-    /**
-     * Whether to carry over parameter annotations on the copied constructors.
-     * Currently Closure annotation members are not supported.
-     *
-     * @return true if copied constructor should keep parameter annotations
-     */
-    boolean parameterAnnotations() default false;
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/MapConstructor.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/MapConstructor.java b/src/main/groovy/transform/MapConstructor.java
deleted file mode 100644
index 5608001..0000000
--- a/src/main/groovy/transform/MapConstructor.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Class annotation used to assist in the creation of map constructors in classes.
- * <p>
- * It allows you to write classes in this shortened form:
- * <pre class="groovyTestCase">
- * import groovy.transform.*
- *
- * {@code @TupleConstructor}
- * class Person {
- *     String first, last
- * }
- *
- * {@code @CompileStatic} // optional
- * {@code @ToString(includeSuperProperties=true)}
- * {@code @MapConstructor}(pre={ super(args?.first, args?.last); args = args ?: [:] }, post = { first = first?.toUpperCase() })
- * class Author extends Person {
- *     String bookName
- * }
- *
- * assert new Author(first: 'Dierk', last: 'Koenig', bookName: 'ReGinA').toString() == 'Author(ReGinA, DIERK, Koenig)'
- * assert new Author().toString() == 'Author(null, null, null)'
- * </pre>
- * The {@code @MapConstructor} annotation instructs the compiler to execute an
- * AST transformation which adds the necessary constructor method to your class.
- * <p>
- * A map constructor is created which sets properties, and optionally fields and
- * super properties if the property/field name is a key within the map.
- * <p>
- * For the above example, the generated constructor will be something like:
- * <pre>
- * public Author(java.util.Map args) {
- *     super(args?.first, args?.last)
- *     args = args ? args : [:]
- *     if (args.containsKey('bookName')) {
- *         this.bookName = args['bookName']
- *     }
- *     first = first?.toUpperCase()
- * }
- * </pre>
- *
- * @since 2.5.0
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.TYPE})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.MapConstructorASTTransformation")
-public @interface MapConstructor {
-    /**
-     * List of field and/or property names to exclude from the constructor.
-     * Must not be used if 'includes' is used. For convenience, a String with comma separated names
-     * can be used in addition to an array (using Groovy's literal list notation) of String values.
-     */
-    String[] excludes() default {};
-
-    /**
-     * List of field and/or property names to include within the constructor.
-     * Must not be used if 'excludes' is used. For convenience, a String with comma separated names
-     * can be used in addition to an array (using Groovy's literal list notation) of String values.
-     * The default value is a special marker value indicating that no includes are defined; all fields and/or properties
-     * are included if 'includes' remains undefined and 'excludes' is explicitly or implicitly an empty list.
-     */
-    String[] includes() default {Undefined.STRING};
-
-    /**
-     * Include fields in the constructor.
-     */
-    boolean includeFields() default false;
-
-    /**
-     * Include properties in the constructor.
-     */
-    boolean includeProperties() default true;
-
-    /**
-     * Include properties from super classes in the constructor.
-     */
-    boolean includeSuperProperties() default false;
-
-    /**
-     * By default, properties are set directly using their respective field.
-     * By setting {@code useSetters=true} then a writable property will be set using its setter.
-     * If turning on this flag we recommend that setters that might be called are
-     * made null-safe wrt the parameter.
-     */
-    boolean useSetters() default false;
-
-    /**
-     * A Closure containing statements which will be prepended to the generated constructor. The first statement within the Closure may be "super(someArgs)" in which case the no-arg super constructor won't be called.
-     */
-    Class pre() default Undefined.CLASS.class;
-
-    /**
-     * A Closure containing statements which will be appended to the end of the generated constructor. Useful for validation steps or tweaking the populated fields/properties.
-     */
-    Class post() default Undefined.CLASS.class;
-
-    /**
-     * Whether to include all fields and/or properties within the constructor, including those with names that are considered internal.
-     */
-    boolean allNames() default false;
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/Memoized.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/Memoized.java b/src/main/groovy/transform/Memoized.java
deleted file mode 100644
index efecb17..0000000
--- a/src/main/groovy/transform/Memoized.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Method annotation that creates a cache for the results of the execution of the annotated method. Whenever the method
- * is called, the mapping between the parameters and the return value is preserved in a cache making subsequent calls with
- * the same arguments fast.
- * 
- * <p>
- * Example usage:
- * 
- * <pre>
- * class MemoizedExample {
- * 
- *     {@code @Memoized}
- *     int sum(int n1, int n2) {
- *         println "$n1 + $n2 = ${n1 + n2}" 
- *         n1 + n2
- *     }
- * }
- * </pre>
- * 
- * which becomes (approximately):
- * 
- * <pre>
- * class MemoizedExample {
- * 
- *     private final Closure memoizedSum = { int n1, int n2 ->
- *         private$method$memoizedSum(n1,n2)
- *     }.memoize()
- * 
- *     int sum(int n1, int n2) {
- *         memoizedSum(n1, n2)
- *     }
- *
- *     private private$method$memoizedSum(int n1, int n2) {
- *         println "$n1 + $n2 = ${n1 + n2}"
- *         n1 + n2
- *     }
- * }
- * </pre>
- * 
- * <p>
- * Upon execution of this code:
- * 
- * <pre>
- * def instance = new MemoizedExample()
- * println instance.sum(1, 2)
- * println instance.sum(1, 2)
- * println instance.sum(2, 3)
- * println instance.sum(2, 3)
- * </pre>
- * 
- * The following will be output:
- * 
- * <pre>
- * 1 + 2 = 3
- * 3
- * 3
- * 2 + 3 = 5
- * 5
- * 5
- * </pre>
- * 
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * import groovy.transform.*
- *
- * // Script variable which is changed when increment()
- * // method is invoked. 
- * // If cached method call is invoked then the value
- * // of this variable will not change.
- * &#64;Field boolean incrementChange = false
- *
- * &#64;Memoized 
- * int increment(int value) {
- *     incrementChange = true
- *     value + 1 
- * }
- *
- * // Invoke increment with argument 10.
- * increment(10)
- *
- * // increment is invoked so incrementChange is true.
- * assert incrementChange
- *
- * // Set incrementChange back to false.
- * incrementChange = false
- *
- * // Invoke increment with argument 10.
- * increment(10)
- *
- * // Now the cached method is used and
- * // incrementChange is not changed.
- * assert !incrementChange
- *
- * // Invoke increment with other argument value.
- * increment(11)
- *
- * // increment is invoked so incrementChange is true.
- * assert incrementChange
- * </pre>
- * 
- * @author Andrey Bloschetsov
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ ElementType.METHOD })
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.MemoizedASTTransformation")
-public @interface Memoized {
-    
-    /**
-     * Number of cached return values to protect from garbage collection.
-     */
-    int protectedCacheSize() default 0;
-    
-    /**
-     * The maximum size the cache can grow to.
-     */
-    int maxCacheSize() default 0;
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/PackageScope.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/PackageScope.java b/src/main/groovy/transform/PackageScope.java
deleted file mode 100644
index 1bcec9c..0000000
--- a/src/main/groovy/transform/PackageScope.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used for turning off Groovy's auto visibility conventions.
- * By default, Groovy automatically turns package protected fields into properties
- * and makes package protected methods, constructors and classes public.
- * This annotation allows this feature to be turned
- * off and revert back to Java behavior if needed.
- *
- * Place it on classes, fields, constructors or methods of interest as follows:
- * <pre>
- * {@code @}PackageScope class Bar {      // package protected
- *     {@code @}PackageScope int field    // package protected; not a property
- *     {@code @}PackageScope method(){}   // package protected
- * }
- * </pre>
- * or for greater control, at the class level with one or more
- * <code>PackageScopeTarget</code> values:
- * <pre>
- * import static groovy.transform.PackageScopeTarget.*
- * {@code @}PackageScope([CLASS, FIELDS])
- * class Foo {              // class will have package protected scope
- *     int field1, field2   // both package protected
- *     def method(){}       // public
- * }
- * {@code @}PackageScope(METHODS)
- * class Bar {         // public
- *     int field       // treated as a property
- *     def method1(){} // package protected
- *     def method2(){} // package protected
- * }
- * </pre>
- *
- * This transformation is not frequently needed but can be useful in certain testing scenarios
- * or when using a third-party library or framework which relies upon package scoping.
- *
- * @author Paul King
- * @since 1.8.0
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.PackageScopeASTTransformation")
-public @interface PackageScope {
-    groovy.transform.PackageScopeTarget[] value() default {PackageScopeTarget.CLASS};
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/PackageScopeTarget.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/PackageScopeTarget.java b/src/main/groovy/transform/PackageScopeTarget.java
deleted file mode 100644
index 07c9bae..0000000
--- a/src/main/groovy/transform/PackageScopeTarget.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-/**
- * Intended target when {@code @}PackageScope is placed at the class level.
- *
- * @author Paul King
- * @since 1.8.0
- */
-public enum PackageScopeTarget {
-    /**
-     * Make the Class have package protected visibility.
-     */
-    CLASS,
-
-    /**
-     * Make the Class methods have package protected visibility.
-     */
-    METHODS,
-
-    /**
-     * Make the Class fields have package protected visibility.
-     */
-    FIELDS,
-
-    /**
-     * Make the Class constructors have package protected visibility.
-     */
-    CONSTRUCTORS
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/SelfType.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/SelfType.java b/src/main/groovy/transform/SelfType.java
deleted file mode 100644
index 5b2ccb3..0000000
--- a/src/main/groovy/transform/SelfType.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * This annotation can be added on a trait to declare the list of types that a class
- * implementing that trait is supposed to extend. This is useful when you want to be
- * able to call methods from the class implementing the trait without having to declare
- * all of them as members of the trait.
- *
- * Self types are particularly useful in combination with {@link groovy.transform.CompileStatic},
- * if you know that a trait can only be applied to a specific type but that the trait cannot extend
- * that type itself. For example, imagine the following code:
- * <pre><code>
- *     class Component { void methodInComponent() }
- *     trait ComponentDecorator {
- *         void logAndCall() {
- *             println "Calling method in component"
- *             methodInComponent()
- *         }
- *         // other useful methods
- *     }
- *     class DecoratedComponent extends Component implements ComponentDecorator {}
- * </code></pre>
- *
- * This will work because the trait uses the dynamic backend, so there is no check at
- * compile time that the <i>methodInComponent</i> call in <i>logAndCall</i> is actually
- * defined. If you annotate the trait with {@link groovy.transform.CompileStatic}, compilation
- * will fail because the trait does not define the method. To declare that the trait can be
- * applied on something that will extend <i>Component</i>, you need to add the <i>SelfType</i>
- * annotation like this:
- * <pre><code>
- *     class Component { void methodInComponent() }
- *
- *     {@literal @}CompileStatic
- *     {@literal @}SelfType(Component)
- *     trait ComponentDecorator {
- *         void logAndCall() {
- *             println "Calling method in component"
- *             methodInComponent()
- *         }
- *         // other useful methods
- *     }
- *     class DecoratedComponent extends Component implements ComponentDecorator {}
- * </code></pre>
- *
- * This pattern can therefore be used to avoid explicit casts everywhere you need to call a method
- * that you know is defined in the class that will implement the trait but normally don't have access
- * to, which is often the case where a trait needs to be applied on a class provided by a third-party
- * library.
- *
- * @author C├ędric Champeau
- * @since 2.4.0
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE})
-public @interface SelfType {
-    Class[] value();
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/Sortable.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/Sortable.java b/src/main/groovy/transform/Sortable.java
deleted file mode 100644
index b235bfa..0000000
--- a/src/main/groovy/transform/Sortable.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * A class annotation used to make a class Comparable by multiple Comparators.
- *
- * As an example, given this class:
- * <pre>
- * {@code @Sortable} class Person {
- *     String first
- *     String last
- *     Integer born
- * }
- * </pre>
- * The generated Groovy class will:
- * <ul>
- *     <li>implement the {@code Comparable} interface</li>
- *     <li>have a {@code compareTo} method based on the {@code first},
- *     {@code last} and {@code born} properties (priority ordering will be according
- *     to the ordering of property definition, highest first, unless 'includes' is used; in which case,
- *     priority will be according to the order given in the includes list)</li>
- *     <li>have three {@code Comparator} methods named {@code comparatorByFirst},
- *     {@code comparatorByLast} and {@code comparatorByBorn}</li>
- *     <li>sort by natural order by default, reversed natural order can be specified</li>
- * </ul>
- * The properties within the class must themselves be {@code Comparable} or {@code @Sortable}.
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * import groovy.transform.Sortable
- * import groovy.transform.ToString
- *
- * &#64;Sortable
- * &#64;ToString
- * class Course {
- *     // Order of properties determines priority when sorting
- *     String title
- *     Date beginDate
- *     Integer maxAttendees  // int doesn't implement Comparable, so use Integer
- * }
- *
- *
- * final Course groovy = new Course(
- *         title: 'Groovy', beginDate: new Date() + 7, maxAttendees: 40)
- * final Course groovy2 = new Course(
- *         title: 'Groovy', beginDate: new Date() + 2, maxAttendees: 50)
- * final Course grails = new Course(
- *         title: 'Grails', beginDate: new Date() + 1, maxAttendees: 20)
- *
- *
- * final List&lt;Course&gt; courses = [groovy, groovy2, grails]
- * assert courses.last().title == 'Grails'
- *
- * // Use toSorted() method to sort
- * final List&lt;Course&gt; sorted = courses.toSorted()
- *
- * assert sorted.first().title == 'Grails'
- * assert sorted.last().title == 'Groovy'
- * assert sorted.maxAttendees == [20, 50, 40]
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // Order of fields for includes determines priority when sorting
- * import groovy.transform.Sortable
- * import groovy.transform.ToString
- *
- * &#64;Sortable(includes = ['title', 'maxAttendees'])
- * // Or &#64;Sortable(excludes = ['beginDate'])
- * &#64;ToString
- * class Course {
- *     String title
- *     Date beginDate
- *     Integer maxAttendees
- * }
- *
- * final Course groovy = new Course(
- *         title: 'Groovy', beginDate: new Date() + 7, maxAttendees: 40)
- * final Course groovy2 = new Course(
- *         title: 'Groovy', beginDate: new Date() + 2, maxAttendees: 50)
- * final Course grails = new Course(
- *         title: 'Grails', beginDate: new Date() + 1, maxAttendees: 20)
- *
- *
- * final List&lt;Course&gt; courses = [groovy, groovy2, grails]
- *
- * // Use toSorted() method to sort
- * final List&lt;Course&gt; sorted = courses.toSorted()
- *
- * assert sorted.first().title == 'Grails'
- * assert sorted.last().title == 'Groovy'
- * assert sorted.maxAttendees == [20, 40, 50]
- *
- * //--------------------------------------------------------------------------
- * // Static methods to create comparators.
- * final Comparator byMaxAttendees = Course.comparatorByMaxAttendees()
- * final List&lt;Course&gt; sortedByMaxAttendees = courses.sort(false, byMaxAttendees)
- *
- * assert sortedByMaxAttendees.maxAttendees == [20, 40, 50]
- * // beginDate is not used for sorting
- * assert sortedByMaxAttendees[2].beginDate &lt; sortedByMaxAttendees[1].beginDate
- *
- * assert Course.declaredMethods.name.findAll { it.startsWith('comparatorBy') }.toSorted() == ['comparatorByMaxAttendees', 'comparatorByTitle']
- *
- * //--------------------------------------------------------------------------
- * // Sorting by max attendees using reversed order
- * import groovy.transform.Sortable
- * import groovy.transform.ToString
- *
- * &#64;Sortable(includes = ['points'], reversed = true)
- * &#64;ToString
- * class LeaderBoardEntry {
- *     String team
- *     int points
- * }
- *
- *
- * final LeaderBoardEntry teamA = new LeaderBoardEntry(team: "Team A", points: 30)
- * final LeaderBoardEntry teamB = new LeaderBoardEntry(team: "Team B", points: 80)
- * final LeaderBoardEntry teamC = new LeaderBoardEntry(team: "Team C", points: 50)
- *
- * final List&lt;LeaderBoardEntry&gt; leaderBoard = [teamA, teamB, teamC].toSorted()
- *
- * assert leaderBoard.first().team == 'Team B'
- * assert leaderBoard.last().team == 'Team A'
- * assert leaderBoard.points == [80, 50, 30]
- *
- * </pre>
- *
- * @author Andres Almiray
- * @author Paul King
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.SortableASTTransformation")
-public @interface Sortable {
-    /**
-     * Property names to include in the comparison algorithm.
-     * Must not be used if 'excludes' is used.
-     * The default value is a special marker value indicating that no includes are defined; all properties
-     * are included if 'includes' remains undefined and 'excludes' is explicitly or implicitly an empty list.
-     */
-    String[] includes() default {Undefined.STRING};
-
-    /**
-     * Property names to exclude in the comparison algorithm.
-     * Must not be used if 'includes' is used.
-     */
-    String[] excludes() default {};
-
-    /**
-     * Set to true so that comparator uses reversed natural order.
-     * @since 2.5.0
-     */
-    boolean reversed() default false;
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/SourceURI.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/SourceURI.java b/src/main/groovy/transform/SourceURI.java
deleted file mode 100644
index 4104369..0000000
--- a/src/main/groovy/transform/SourceURI.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Variable annotation used for getting the URI of the current script.
- * <p>
- * The type of the variable annotated with {@code @SourceURI} must be assignment compatible with {@link java.net.URI}.
- * It will be used to hold a URI object that references the source for the current script.
- * </p><p>By default the URI
- * will be made absolute (which is to say it will have an authority) in the case where a relative path was used
- * for the source of the script.  If you want to leave relative URIs as relative, then set <code>allowRelative</code>
- * to <code>true</code>.
- * </p>
- *
- * Example usage:
- * <pre class="groovyTestCase">
- * {@code @groovy.transform.SourceURI} def sourceURI
- *
- * assert sourceURI instanceof java.net.URI
- * </pre>
- *
- * @author Jim White
- * @since 2.3.0
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.LOCAL_VARIABLE, ElementType.FIELD})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.SourceURIASTTransformation")
-public @interface SourceURI {
-    boolean allowRelative() default false;
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/Synchronized.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/Synchronized.java b/src/main/groovy/transform/Synchronized.java
deleted file mode 100644
index dc8867c..0000000
--- a/src/main/groovy/transform/Synchronized.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Method annotation to make a method call synchronized for concurrency handling
- * with some useful baked-in conventions.
- * <p>
- * {@code @Synchronized} is a safer variant of the <code>synchronized</code> method modifier.
- * The annotation can only be used on static and instance methods. It operates similarly to
- * the <code>synchronized</code> keyword, but it locks on different objects. When used with
- * an instance method, the <code>synchronized</code> keyword locks on <code>this</code>, but the annotation
- * locks on a (by default automatically generated) field named <code>$lock</code>.
- * If the field does not exist, it is created for you. If you annotate a static method,
- * the annotation locks on a static field named <code>$LOCK</code> instead.
- * <p>
- * If you want, you can create these locks yourself.
- * The <code>$lock</code> and <code>$LOCK</code> fields will not be generated if you create
- * them yourself. You can also choose to lock on another field, by specifying its name as
- * parameter to the {@code @Synchronized} annotation. In this usage variant, the lock field
- * will not be created automatically, and you must explicitly create it yourself.
- * <p>
- * <em>Rationale:</em> Locking on <code>this</code> or your own class object can have unfortunate side-effects,
- * as other code not under your control can lock on these objects as well, which can
- * cause race conditions and other nasty threading-related bugs.
- * <p>
- * <em>Example usage:</em>
- * <pre>
- * class SynchronizedExample {
- *   private final myLock = new Object()
- *
- *   {@code @}Synchronized
- *   static void greet() {
- *     println "world"
- *   }
- *
- *   {@code @}Synchronized
- *   int answerToEverything() {
- *     return 42
- *   }
- *
- *   {@code @}Synchronized("myLock")
- *   void foo() {
- *     println "bar"
- *   }
- * }
- * </pre>
- * which becomes:
- * <pre>
- * class SynchronizedExample {
- *   private static final $LOCK = new Object[0]
- *   private final $lock = new Object[0]
- *   private final myLock = new Object()
- *
- *   static void greet() {
- *     synchronized($LOCK) {
- *       println "world"
- *     }
- *   }
- *
- *   int answerToEverything() {
- *     synchronized($lock) {
- *       return 42
- *     }
- *   }
- *
- *   void foo() {
- *     synchronized(myLock) {
- *       println "bar"
- *     }
- *   }
- * }
- * </pre>
- *
- * <em>Credits:</em> this annotation is inspired by the Project Lombok annotation of the
- * same name. The functionality has been kept similar to ease the learning
- * curve when swapping between these two tools.
- * <p>
- * <em>Details:</em> If <code>$lock</code> and/or <code>$LOCK</code> are auto-generated, the fields are initialized
- * with an empty <code>Object[]</code> array, and not just a new <code>Object()</code> as many snippets using
- * this pattern tend to use. This is because a new <code>Object</code> is NOT serializable, but
- * a 0-size array is. Therefore, using {@code @Synchronized} will not prevent your
- * object from being serialized.
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * import groovy.transform.Synchronized
- *
- * class Util {
- *     private counter = 0
- *
- *     private def list = ['Groovy']
- *
- *     private Object listLock = new Object[0]
- *
- *     &#64;Synchronized
- *     void workOnCounter() {
- *         assert 0 == counter
- *         counter++
- *         assert 1 == counter
- *         counter --
- *         assert 0 == counter
- *     }
- *
- *     &#64;Synchronized('listLock')
- *     void workOnList() {
- *         assert 'Groovy' == list[0]
- *         list &lt;&lt; 'Grails'
- *         assert 2 == list.size()
- *         list = list - 'Grails'
- *         assert 'Groovy' == list[0]
- *     }
- * }
- *
- * def util = new Util()
- * def tc1 = Thread.start {
- *     100.times {
- *         util.workOnCounter()
- *         sleep 20 
- *         util.workOnList()
- *         sleep 10
- *     }
- * }
- * def tc2 = Thread.start {
- *     100.times {
- *         util.workOnCounter()
- *         sleep 10 
- *         util.workOnList()
- *         sleep 15
- *     }
- * }
- * tc1.join()
- * tc2.join()
- * </pre>
- *
- * @author Paul King
- * @since 1.7.3
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.METHOD})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.SynchronizedASTTransformation")
-public @interface Synchronized {
-    /**
-     * @return if a user specified lock object with the given name should be used
-     */
-    String value () default "";
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/TailRecursive.groovy
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/TailRecursive.groovy b/src/main/groovy/transform/TailRecursive.groovy
deleted file mode 100644
index afbee50..0000000
--- a/src/main/groovy/transform/TailRecursive.groovy
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass
-
-import java.lang.annotation.ElementType
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-import java.lang.annotation.Target
-
-/**
- * Method annotation used to transform methods with tail recursive calls into iterative methods automagically
- * since the JVM cannot do this itself. This works for both static and non-static methods.
- * <p/>
- * It allows you to write a method like this:
- * <pre class="groovyTestCase">
- * import groovy.transform.TailRecursive
- * class Target {
- *      {@code @TailRecursive}
- *      long sumUp(long number, long sum = 0) {
- *          if (number == 0)
- *              return sum;
- *          sumUp(number - 1, sum + number)
- *      }
- * }
- * def target = new Target()
- * assert target.sumUp(100) == 5050
- * assert target.sumUp(1000000) == 500000500000 //will blow the stack on most machines when used without {@code @TailRecursive}
- * </pre>
- *
- * {@code @TailRecursive} is supposed to work in combination with {@code @CompileStatic}
- *
- * Known shortcomings:
- * <ul>
- * <li>Only non-void methods are currently being handled. Void methods will fail compilation.
- * <li>Only direct recursion (calling the exact same method again) is supported.
- * <li>Mixing of tail calls and non-tail calls is not possible. The compiler will complain if some recursive calls cannot be handled.
- * <li>Checking if a recursive call is really tail-recursive is not very strict. You might run into cases where non-tail calls will be considered tail calls.
- * <li>In the presence of method overloading and method overriding you might run into situations where a call is considered recursive although it really is not.
- * <li>Catching {@code Throwable} around a recursive might lead to problems
- * <li>Non trivial continuation passing style examples do not work.
- * <li>Probably many unrecognized edge cases.
- * </ul>
- * 
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * import groovy.transform.TailRecursive
- *
- * &#64;TailRecursive
- * long sizeOfList(list, counter = 0) {
- *     if (list.size() == 0) {
- *         counter
- *     } else {
- *        sizeOfList(list.tail(), counter + 1) 
- *     }
- * }
- *
- * // Without &#64;TailRecursive a StackOverFlowError
- * // is thrown.
- * assert sizeOfList(1..10000) == 10000
- * </pre>
- *
- * @author Johannes Link
- * @since 2.3
- */
-@Retention(RetentionPolicy.SOURCE)
-@Target([ElementType.METHOD])
-@GroovyASTTransformationClass(["org.codehaus.groovy.transform.tailrec.TailRecursiveASTTransformation"])
-public @interface TailRecursive {
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/ThreadInterrupt.groovy
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/ThreadInterrupt.groovy b/src/main/groovy/transform/ThreadInterrupt.groovy
deleted file mode 100644
index 817507a..0000000
--- a/src/main/groovy/transform/ThreadInterrupt.groovy
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass
-
-import java.lang.annotation.Documented
-import java.lang.annotation.ElementType
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-import java.lang.annotation.Target
-
-/**
- * Allows "interrupt-safe" executions of scripts by adding Thread.currentThread().isInterrupted()
- * checks into loops (for, while) and at the start of closures and methods.
- * <p>
- * This is especially useful when executing foreign scripts that you do not have control over. Inject this
- * transformation into a script that you need to interrupt.
- * <p>
- * Annotating anything in a script will cause for loops, while loops, methods, and closures to make an
- * isInterruptedCheck and throw a InterruptedException if the check yields true. The annotation by default
- * will apply to any classes defined in the script as well. Annotated a class will cause (by default) all classes
- * in the entire file ('Compilation Unit') to be enhanced. You can fine tune what is enhanced using the annotation
- * parameters. 
- * <p>
- * The following is sample usage of the annotation:
- *
- * <pre>
- * <code>@groovy.transform.ThreadInterrupt</code>
- * def scriptMethod() {
- *   4.times {
- *     println 'executing script method...'
- *   }
- * }
- *
- * class MyClass {
- *   def myMethod() {
- *     for (i in (1..10)) {
- *       println 'executing method...'
- *     }
- *   }
- * }
- *
- * scriptMethod()
- * new MyClass().myMethod()
- * </pre>
- *
- * Which results in the following code being generated. Notice the checks and exceptions:
- *
- * <pre>
- * public class script1290627909406 extends groovy.lang.Script {
- *
- *     public java.lang.Object scriptMethod() {
- *         if (java.lang.Thread.currentThread().isInterrupted()) {
- *             throw new java.lang.InterruptedException('Execution Interrupted')
- *         }
- *         4.times({
- *             if (java.lang.Thread.currentThread().isInterrupted()) {
- *                 throw new java.lang.InterruptedException('Execution Interrupted')
- *             }
- *             this.println('executing script method...')
- *         })
- *     }
- * }
- * public class MyClass extends java.lang.Object {
- *
- *   public java.lang.Object myMethod() {
- *     if (java.lang.Thread.currentThread().isInterrupted()) {
- *       throw new java.lang.InterruptedException('Execution Interrupted')
- *     }
- *     for (java.lang.Object i : (1..10)) {
- *       if (java.lang.Thread.currentThread().isInterrupted()) {
- *         throw new java.lang.InterruptedException('Execution Interrupted')
- *       }
- *       this.println('executing method...')
- *     }
- *   }
- * }
- *
- * this.scriptMethod()
- * new MyClass().myMethod()
- * </pre>
- * Additional usage examples can be found in the unit test for this class.
- *
- * @see TimedInterrupt
- * @see ConditionalInterrupt
- * @author Cedric Champeau
- * @author Hamlet D'Arcy
- * @author Paul King
- * @since 1.8.0
- */
-@Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target([ElementType.PACKAGE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.LOCAL_VARIABLE])
-@GroovyASTTransformationClass(["org.codehaus.groovy.transform.ThreadInterruptibleASTTransformation"])
-@interface ThreadInterrupt {
-  /**
-   * Set this to false if you have multiple classes within one source file and only
-   * want isInterrupted checks on some of the classes. Place annotations on the classes
-   * you want enhanced. Set to true (the default) for blanket coverage of isInterrupted
-   * checks on all methods, loops and closures within all classes/script code.
-   *
-   * For even finer-grained control see {@code applyToAllMembers}.
-   *
-   * @see #applyToAllMembers()
-   */
-  boolean applyToAllClasses() default true
-
-  /**
-   * Set this to false if you have multiple methods/closures within a class or script and only
-   * want isInterrupted checks on some of them. Place annotations on the methods/closures that
-   * you want enhanced. When false, {@code applyToAllClasses} is automatically set to false.
-   *
-   * Set to true (the default) for blanket coverage of isInterrupted checks on all methods, loops
-   * and closures within the class/script.
-   *
-   * @since 2.2.0
-   * @see #applyToAllClasses()
-   */
-  boolean applyToAllMembers() default true
-
-  /**
-   * By default an isInterrupted check is added to the start of all user-defined methods. To turn this off simply
-   * set this parameter to false.
-   */
-  boolean checkOnMethodStart() default true
-
-  /**
-   * Sets the type of exception which is thrown.
-   */
-  Class thrown() default InterruptedException
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/TimedInterrupt.groovy
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/TimedInterrupt.groovy b/src/main/groovy/transform/TimedInterrupt.groovy
deleted file mode 100644
index 0a0c193..0000000
--- a/src/main/groovy/transform/TimedInterrupt.groovy
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass
-
-import java.lang.annotation.Documented
-import java.lang.annotation.ElementType
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-import java.lang.annotation.Target
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
-
-/**
- * Allows safe timed executions of scripts by adding elapsed time checks into loops (for, while)
- * and at the start of closures and methods and throwing an exception if a timeout occurs.
- * <p>
- * This is especially useful when executing foreign scripts that you do not have control over.
- * Inject this transformation into a script that you want to timeout after a specified amount of time.
- * <p>
- * Annotating anything in a script will cause for loops, while loops, methods, and closures to make an
- * elapsed time check and throw a TimeoutException if the check yields true. The annotation by default
- * will apply to any classes defined in the script as well. Annotating a class will cause (by default)
- * all classes in the entire file ('Compilation Unit') to be enhanced. You can fine tune what is
- * enhanced using the annotation parameters. Static methods and static fields are ignored.
- * <p>
- * The following is sample usage of the annotation forcing the script to timeout after 5 minutes (300 seconds):
- *
- * <pre>
- * import groovy.transform.TimedInterrupt
- * import java.util.concurrent.TimeUnit
- *
- * {@code @TimedInterrupt}(value = 300L, unit = TimeUnit.SECONDS)
- * class MyClass {
- *      def method() {
- *          println '...'
- *      }
- * }
- * </pre>
- * This sample script will be transformed at compile time to something that resembles this:
- * <pre>
- * import java.util.concurrent.TimeUnit
- * import java.util.concurrent.TimeoutException
- *
- * public class MyClass {
- *     // XXXXXX below is a placeholder for a hashCode value at runtime
- *     final private long timedInterruptXXXXXX$expireTime
- *     final private java.util.Date timedInterruptXXXXXX$startTime
- *
- *     public MyClass() {
- *         timedInterruptXXXXXX$expireTime = System.nanoTime() + TimeUnit.NANOSECONDS.convert(300, TimeUnit.SECONDS)
- *         timedInterruptXXXXXX$startTime = new java.util.Date()
- *     }
- *
- *     public java.lang.Object method() {
- *         if (timedInterruptXXXXXX$expireTime < System.nanoTime()) {
- *             throw new TimeoutException('Execution timed out after 300 units. Start time: ' + timedInterruptXXXXXX$startTime)
- *         }
- *         return this.println('...')
- *     }
- * }
- * </pre>
- * See the unit test for this class for additional examples.
- *
- * @author Hamlet D'Arcy
- * @author Cedric Champeau
- * @author Paul King
- * @see ThreadInterrupt
- * @see ConditionalInterrupt
- * @since 1.8.0
- */
-@Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target([ ElementType.PACKAGE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.LOCAL_VARIABLE])
-@GroovyASTTransformationClass(["org.codehaus.groovy.transform.TimedInterruptibleASTTransformation"])
-@interface TimedInterrupt {
-    /**
-     * Set this to false if you have multiple classes within one source file and only want
-     * timeout checks on some of the classes (or you want different time constraints on different classes).
-     * Place an annotation with appropriate parameters on each class you want enhanced.
-     * Set to true (the default) for blanket coverage of timeout checks on all methods, loops
-     * and closures within all classes/script code.
-     *
-     * For even finer-grained control see {@code applyToAllMembers}.
-     *
-     * @see #applyToAllMembers()
-     */
-    boolean applyToAllClasses() default true
-
-    /**
-     * Set this to false if you have multiple methods/closures within a class or script and only
-     * want timeout checks on some of them (or you want different time constraints on different methods/closures).
-     * Place annotations with appropriate parameters on the methods/closures that you want enhanced.
-     * When false, {@code applyToAllClasses} is automatically set to false.
-     *
-     * Set to true (the default) for blanket coverage of timeout checks on all methods, loops
-     * and closures within the class/script.
-     *
-     * @since 2.2.0
-     * @see #applyToAllClasses()
-     */
-    boolean applyToAllMembers() default true
-
-    /**
-     * By default a time check is added to the start of all user-defined methods. To turn this off
-     * simply set this parameter to false.
-     */
-    boolean checkOnMethodStart() default true
-
-    /**
-     * The maximum elapsed time the script will be allowed to run for. By default it is measure in seconds
-     */
-    long value()
-
-    /**
-     * The TimeUnit of the value parameter. By default it is TimeUnit.SECONDS.
-     */
-    TimeUnit unit() default TimeUnit.SECONDS
-
-    /**
-     * The type of exception thrown when timeout is reached.
-     */
-    Class thrown() default TimeoutException
-}
-

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/ToString.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/ToString.java b/src/main/groovy/transform/ToString.java
deleted file mode 100644
index 9fc4627..0000000
--- a/src/main/groovy/transform/ToString.java
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Class annotation used to assist in the creation of {@code toString()} methods in classes.
- * The {@code @ToString} annotation instructs the compiler to execute an
- * AST transformation which adds the necessary toString() method.
- * <p>
- * It allows you to write classes in this shortened form:
- * <pre>
- * {@code @ToString}
- * class Customer {
- *     String first, last
- *     int age
- *     Date since = new Date()
- *     Collection favItems
- *     private answer = 42
- * }
- * println new Customer(first:'Tom', last:'Jones', age:21, favItems:['Books', 'Games'])
- * </pre>
- * Which will have this output:
- * <pre>
- * Customer(Tom, Jones, 21, Wed Jul 14 23:57:14 EST 2010, [Books, Games])
- * </pre>
- * There are numerous options to customize the format of the generated output.
- * E.g. if you change the first annotation to:
- * <pre>
- * {@code @ToString(includeNames=true)}
- * </pre>
- * Then the output will be:
- * <pre>
- * Customer(first:Tom, last:Jones, age:21, since:Wed Jul 14 23:57:50 EST 2010, favItems:[Books, Games])
- * </pre>
- * Or if you change the first annotation to:
- * <pre>
- * {@code @ToString(includeNames=true,includeFields=true,excludes="since,favItems")}
- * </pre>
- * Then the output will be:
- * <pre>
- * Customer(first:Tom, last:Jones, age:21, answer:42)
- * </pre>
- * If you have this example:
- * <pre class="groovyTestCase">
- * import groovy.transform.ToString
- * {@code @ToString} class NamedThing {
- *     String name
- * }
- * {@code @ToString}(includeNames=true,includeSuper=true)
- * class AgedThing extends NamedThing {
- *     int age
- * }
- * String agedThingAsString = new AgedThing(name:'Lassie', age:5).toString()
- * assert agedThingAsString == 'AgedThing(age:5, super:NamedThing(Lassie))'
- * </pre>
- * {@code @ToString} can also be used in conjunction with {@code @Canonical} and {@code @Immutable}.
- * <p>
- * If you want to omit fields or properties referring to <tt>null</tt>, you can use the <tt>ignoreNulls</tt> flag:
- * <pre class="groovyTestCase">
- * import groovy.transform.ToString
- * {@code @ToString(ignoreNulls = true)} class NamedThing {
- *     String name
- * }
- * assert new NamedThing(name: null).toString() == 'NamedThing()'
- * </pre>
- * <p>
- * By default the fully-qualified class name is used as part of the generated toString.
- * If you want to exclude the package, you can set the includePackage flag to false, e.g.:
- * <pre>
- * package my.company
- * import groovy.transform.ToString
- * {@code @ToString(includePackage = false)} class NamedThing {
- *     String name
- * }
- * println new NamedThing(name: "Lassie")
- * </pre>
- * Which results in:
- * <pre>
- * NamedThing(name: Lassie)
- * </pre>
- * If the includePackage flag is {@code true} (the default), then the output will be:
- * <pre>
- * my.company.NamedThing(name: Lassie)
- * </pre>
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------    
- * // Most simple implementation of toString.
- * import groovy.transform.ToString
- *
- * {@code @ToString}
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- * }
- *
- * def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])
- *
- * assert person.toString() == 'Person(mrhaki, [Groovy, Java])'
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------    
- * // includeNames to output the names of the properties.
- * import groovy.transform.ToString
- *
- * &#64;ToString(includeNames=true)
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- * }
- *
- * def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])
- *
- * assert person.toString() == 'Person(name:mrhaki, likes:[Groovy, Java])'
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // includeFields to not only output properties, but also field values.
- * import groovy.transform.ToString
- *
- * &#64;ToString(includeNames=true, includeFields=true)
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- * }
- *
- * def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])
- *
- * assert person.toString() == 'Person(name:mrhaki, likes:[Groovy, Java], active:false)'
- * </pre>
- * <pre>
- * //--------------------------------------------------------------------------    
- * // Use includeSuper to include properties from super class in output.
- * import groovy.transform.ToString
- *
- * &#64;ToString(includeNames=true)
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- * }
- *
- * &#64;ToString(includeSuper=true, includeNames=true)
- * class Student extends Person {
- *     List courses
- * }
- *
- * def student = new Student(name: 'mrhaki', likes: ['Groovy', 'Java'], courses: ['IT', 'Business'])
- *
- * assert student.toString() == 'Student(courses:[IT, Business], super:Person(name:mrhaki, likes:[Groovy, Java]))'
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------    
- * // excludes active field and likes property from output
- * import groovy.transform.ToString
- *
- * &#64;ToString(includeNames=true, includeFields=true, excludes='active,likes')
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- * }
- *
- * def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])
- *
- * assert person.toString() == 'Person(name:mrhaki)'
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // Don't include the package name in the output
- * package com.mrhaki.blog.groovy
- *
- * import groovy.transform.*
- *
- * &#64;ToString(includePackage=false)
- * class Course {
- *     String title
- *     Integer maxAttendees
- * }
- *
- * final Course course = new Course(title: 'Groovy 101', maxAttendees: 200)
- *
- * assert course.toString() == 'Course(Groovy 101, 200)'
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // Don't use properties with null value.
- * package com.mrhaki.blog.groovy
- *
- * import groovy.transform.*
- *
- * &#64;ToString(ignoreNulls=true)
- * class Course {
- *     String title
- *     Integer maxAttendees
- * }
- *
- * final Course course = new Course(title: 'Groovy 101')
- *
- * assert course.toString() == 'com.mrhaki.blog.groovy.Course(Groovy 101)'
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // Cache toString() result.
- * package com.mrhaki.blog.groovy
- *
- * import groovy.transform.*
- *
- * &#64;ToString(cache=true)
- * class Course {
- *     String title
- *     Integer maxAttendees
- * }
- *
- * Course course = new Course(title: 'Groovy 101', maxAttendees: 200)
- *
- * assert course.toString() == 'com.mrhaki.blog.groovy.Course(Groovy 101, 200)'
- *
- * // Value change will not be reflected in toString().
- * course.title = 'Grails with REST'
- *
- * assert course.toString() == 'com.mrhaki.blog.groovy.Course(Groovy 101, 200)'
- * assert course.title == 'Grails with REST'
- * </pre> 
- *
- * @author Paul King
- * @author Andre Steingress
- * @see groovy.transform.Immutable
- * @see groovy.transform.Canonical
- * @since 1.8.0
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.ToStringASTTransformation")
-public @interface ToString {
-    /**
-     * List of field and/or property names to exclude from generated toString.
-     * Must not be used if 'includes' is used. For convenience, a String with comma separated names
-     * can be used in addition to an array (using Groovy's literal list notation) of String values.
-     */
-    String[] excludes() default {};
-
-    /**
-     * List of field and/or property names to include within the generated toString.
-     * Must not be used if 'excludes' is used. For convenience, a String with comma separated names
-     * can be used in addition to an array (using Groovy's literal list notation) of String values.
-     * The default value is a special marker value indicating that no includes are defined; all fields and/or properties
-     * are included if 'includes' remains undefined and 'excludes' is explicitly or implicitly an empty list.
-     * The special name 'super' can be used instead of using the 'includeSuper' flag.
-     */
-    String[] includes() default {Undefined.STRING};
-
-    /**
-     * Whether to include the toString() of super in the generated toString.
-     */
-    boolean includeSuper() default false;
-
-    /**
-     * Whether to include super properties in the generated toString.
-     * @since 2.4.0
-     */
-    boolean includeSuperProperties() default false;
-
-    /**
-     * Whether to include names of properties/fields in the generated toString.
-     */
-    boolean includeNames() default false;
-
-    /**
-     * Include fields as well as properties in the generated toString.
-     */
-    boolean includeFields() default false;
-
-    /**
-     * Don't display any fields or properties with value <tt>null</tt>.
-     */
-    boolean ignoreNulls() default false;
-
-    /**
-     * Whether to include the fully-qualified class name (i.e. including
-     * the package) or just the simple class name in the generated toString.
-     * @since 2.0.6
-     */
-    boolean includePackage() default true;
-
-    /**
-     * Whether to include all properties (as per the JavaBean spec) in the generated toString.
-     * Groovy recognizes any field-like definitions with no explicit visibility as property definitions
-     * and always includes them in the {@code @ToString} generated toString (as well as auto-generating the
-     * appropriate getters and setters). Groovy also treats any explicitly created getXxx() or isYyy()
-     * methods as property getters as per the JavaBean specification. Old versions of Groovy did not.
-     * So set this flag to false for the old behavior or if you want to explicitly exclude such properties.
-     *
-     * @since 2.5
-     */
-    boolean allProperties() default true;
-
-    /**
-     * Whether to cache toString() calculations. You should only set this to true if
-     * you know the object is immutable (or technically mutable but never changed).
-     * @since 2.1.0
-     */
-    boolean cache() default false;
-
-    /**
-     * Whether to include all fields and/or properties in the generated toString, including those with names that
-     * are considered internal.
-     *
-     * @since 2.5.0
-     */
-    boolean allNames() default false;
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/Trait.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/Trait.java b/src/main/groovy/transform/Trait.java
deleted file mode 100644
index de88180..0000000
--- a/src/main/groovy/transform/Trait.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used to mark a class as being a trait.
- *
- * @since 2.3.0
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.trait.TraitASTTransformation")
-public @interface Trait {
-}

http://git-wip-us.apache.org/repos/asf/groovy/blob/0ad8c07c/src/main/groovy/transform/TupleConstructor.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/transform/TupleConstructor.java b/src/main/groovy/transform/TupleConstructor.java
deleted file mode 100644
index 89d0eb7..0000000
--- a/src/main/groovy/transform/TupleConstructor.java
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one
- *  or more contributor license agreements.  See the NOTICE file
- *  distributed with this work for additional information
- *  regarding copyright ownership.  The ASF licenses this file
- *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
- *  with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing,
- *  software distributed under the License is distributed on an
- *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *  KIND, either express or implied.  See the License for the
- *  specific language governing permissions and limitations
- *  under the License.
- */
-package groovy.transform;
-
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Class annotation used to assist in the creation of tuple constructors in classes.
- * Should be used with care with other annotations which create constructors - see "Known
- * Limitations" for more details.
- * <p>
- * It allows you to write classes in this shortened form:
- * <pre class="groovyTestCase">
- * {@code @groovy.transform.TupleConstructor} class Customer {
- *     String first, last
- *     int age
- *     Date since
- *     Collection favItems
- * }
- * def c1 = new Customer(first:'Tom', last:'Jones', age:21, since:new Date(), favItems:['Books', 'Games'])
- * def c2 = new Customer('Tom', 'Jones', 21, new Date(), ['Books', 'Games'])
- * def c3 = new Customer('Tom', 'Jones')
- * </pre>
- * The {@code @TupleConstructor} annotation instructs the compiler to execute an
- * AST transformation which adds the necessary constructor method to your class.
- * <p>
- * A tuple constructor is created with a parameter for each property (and optionally field and
- * super properties).
- * A default value is provided (using Java's default values) for all parameters in the constructor.
- * Groovy's normal conventions then allows any number of parameters to be left off the end of the parameter list
- * including all of the parameters - giving a no-arg constructor which can be used with the map-style naming conventions.
- * <p>
- * The order of parameters is given by the properties of any super classes with most super first
- * (if {@code includeSuperProperties} is set) followed by the properties of the class followed
- * by the fields of the class (if {@code includeFields} is set). Within each grouping the order
- * is as attributes appear within the respective class.
- * <p>More examples:</p>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * import groovy.transform.TupleConstructor
- *
- * &#64;TupleConstructor()
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- * }
- *
- * def person = new Person('mrhaki', ['Groovy', 'Java'])
- *
- * assert person.name == 'mrhaki'
- * assert person.likes == ['Groovy', 'Java']
- *
- * person = new Person('mrhaki')
- *
- * assert person.name == 'mrhaki'
- * assert !person.likes
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // includeFields in the constructor creation.
- * import groovy.transform.TupleConstructor
- *
- * &#64;TupleConstructor(includeFields=true)
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- *
- *     boolean isActivated() { active }
- * }
- *
- * def person = new Person('mrhaki', ['Groovy', 'Java'], true)
- *
- * assert person.name == 'mrhaki'
- * assert person.likes == ['Groovy', 'Java']
- * assert person.activated
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // use force attribute to force creation of constructor
- * // even if we define our own constructors.
- * import groovy.transform.TupleConstructor
- *
- * &#64;TupleConstructor(force=true)
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- *
- *     Person(boolean active) {
- *         this.active = active
- *     }
- *
- *     boolean isActivated() { active }
- * }
- *
- * def person = new Person('mrhaki', ['Groovy', 'Java'])
- *
- * assert person.name == 'mrhaki'
- * assert person.likes == ['Groovy', 'Java']
- * assert !person.activated
- *
- * person = new Person(true)
- *
- * assert person.activated
- * </pre>
- * <pre class="groovyTestCase">
- * //--------------------------------------------------------------------------
- * // include properties and fields from super class.
- * import groovy.transform.TupleConstructor
- *
- * &#64;TupleConstructor(includeFields=true)
- * class Person {
- *     String name
- *     List likes
- *     private boolean active = false
- *
- *     boolean isActivated() { active }
- * }
- *
- * &#64;TupleConstructor(callSuper=true, includeSuperProperties=true, includeSuperFields=true)
- * class Student extends Person {
- *     List courses
- * }
- *
- * def student = new Student('mrhaki', ['Groovy', 'Java'], true, ['IT'])
- *
- * assert student.name == 'mrhaki'
- * assert student.likes == ['Groovy', 'Java']
- * assert student.activated
- * assert student.courses == ['IT']
- * </pre>
- * <p>
- * Known Limitations:
- * <ul>
- * <li>This AST transform might become a no-op if you are defining your own constructors or
- * combining with other AST transforms which create constructors (e.g. {@code @InheritConstructors});
- * the order in which the particular transforms are processed becomes important in that case.
- * See the {@code force} attribute for further details about customizing this behavior.</li>
- * <li>This AST transform normally uses default parameter values which creates multiple constructors under
- * the covers. You should use with care if you are defining your own constructors or
- * combining with other AST transforms which create constructors (e.g. {@code @InheritConstructors});
- * the order in which the particular transforms are processed becomes important in that case.
- * See the {@code defaults} attribute for further details about customizing this behavior.</li>
- * <li>Groovy's normal map-style naming conventions will not be available if the first property (or field)
- * has type {@code LinkedHashMap} or if there is a single Map, AbstractMap or HashMap property (or field)</li>
- * </ul>
- *
- * @since 1.8.0
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target({ElementType.TYPE})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.TupleConstructorASTTransformation")
-public @interface TupleConstructor {
-    /**
-     * List of field and/or property names to exclude from the constructor.
-     * Must not be used if 'includes' is used. For convenience, a String with comma separated names
-     * can be used in addition to an array (using Groovy's literal list notation) of String values.
-     */
-    String[] excludes() default {};
-
-    /**
-     * List of field and/or property names to include within the constructor.
-     * Must not be used if 'excludes' is used. For convenience, a String with comma separated names
-     * can be used in addition to an array (using Groovy's literal list notation) of String values.
-     * The default value is a special marker value indicating that no includes are defined;
-     * all fields are included if includes remains undefined and excludes is explicitly or implicitly
-     * an empty list.
-     */
-    String[] includes() default {Undefined.STRING};
-
-    /**
-     * Include fields in the constructor.
-     */
-    boolean includeFields() default false;
-
-    /**
-     * Include properties in the constructor.
-     */
-    boolean includeProperties() default true;
-
-    /**
-     * Include fields from super classes in the constructor.
-     */
-    boolean includeSuperFields() default false;
-
-    /**
-     * Include properties from super classes in the constructor.
-     */
-    boolean includeSuperProperties() default false;
-
-    /**
-     * Should super properties be called within a call to the parent constructor
-     * rather than set as properties. Typically used in combination with {@code includeSuperProperties}.
-     * Can't be true if using {@code pre} with a {@code super} first statement.
-     */
-    boolean callSuper() default false;
-
-    /**
-     * By default, this annotation becomes a no-op if you provide your own constructor.
-     * By setting {@code force=true} then the tuple constructor(s) will be added regardless of
-     * whether existing constructors exist. It is up to you to avoid creating duplicate constructors.
-     */
-    boolean force() default false;
-
-    /**
-     * Used to set whether default value processing is enabled (the default) or disabled.
-     *
-     * By default, every constructor parameter is given a default value. This value will
-     * be Java's default for primitive types (zero or false) and null for Objects, unless
-     * an initial value is given when declaring the property or field. A consequence of
-     * this design is that you can leave off parameters from the right if the default
-     * value will suffice. As far as Java interoperability is concerned, Groovy will
-     * create additional constructors under the covers representing the constructors
-     * with parameters left off, all the way from the constructor with all arguments
-     * to the no-arg constructor.
-     *
-     * However, when set to false, default values are not allowed for properties and fields.
-     * Only the constructor containing all arguments will be provided.
-     * In particular, a no-arg constructor won't be provided and since this is currently
-     * used by Groovy when using named-arguments, the named-argument style won't be available.
-     */
-    boolean defaults() default true;
-
-    /**
-     * By default, properties are set directly using their respective field.
-     * By setting {@code useSetters=true} then a writable property will be set using its setter.
-     * If turning on this flag we recommend that setters that might be called are
-     * made null-safe wrt the parameter.
-     */
-    boolean useSetters() default false;
-
-    /**
-     * Whether to include all fields and/or properties within the constructor, including those with names that are
-     * considered internal.
-     *
-     * @since 2.5.0
-     */
-    boolean allNames() default false;
-
-    /**
-     * A Closure containing statements which will be prepended to the generated constructor. The first statement
-     * within the Closure may be {@code super(someArgs)} in which case the no-arg super constructor won't be called.
-     *
-     * @since 2.5.0
-     */
-    Class pre() default Undefined.CLASS.class;
-
-    /**
-     * A Closure containing statements which will be appended to the end of the generated constructor. Useful for validation steps or tweaking the populated fields/properties.
-     *
-     * @since 2.5.0
-     */
-    Class post() default Undefined.CLASS.class;
-}


Mime
View raw message