removed qualifier definition and updated wording after discussion wit…

…h EG;

api/src/main/java/javax/config/ComposedConfig.java

@@ -21,12 +21,11 @@
 
 import javax.config.inject.ConfigProperty;
 import javax.enterprise.util.Nonbinding;
-import javax.inject.Qualifier;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 import java.util.concurrent.TimeUnit;
 
-import static java.lang.annotation.ElementType.*;
+import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
@@ -231,9 +230,8 @@
  *
  * @author <a href="mailto:[email protected]">Sebastian Daschner</a>
  */
-@Qualifier
 @Retention(RUNTIME)
-@Target({METHOD, FIELD, PARAMETER, TYPE})
+@Target(TYPE)
 public @interface ComposedConfig {
 
     /**

api/src/main/java/javax/config/ConfigAccessor.java

@@ -96,17 +96,6 @@ public interface ConfigAccessor<T> {
      */
     ConfigAccessor<T> useConverter(Converter<T> converter);
 
-    /**
-     * Considers the type of the configuration entry a composed type.
-     * This method enables developers to define the look-up of composed type in scenarios where they cannot annotate
-     * the composed type with {@link ComposedConfig}. This is the programmatic equivalent of injecting a composed type
-     * with qualifier {@link ComposedConfig} at the injection point.
-     *
-     * @return This builder
-     * @see ComposedConfig
-     */
-    ConfigAccessor<T> asComposed();
-
     /**
      * Sets the default value to use in case the resolution returns null.
      * @param value the default value

spec/src/main/asciidoc/composed-configuration.adoc

@@ -237,10 +237,7 @@ This information is particularly interesting for implementors.
 
 1. The `Config` implementation detects whether the type of a retrieved configuration value is a composed configuration.
 This is handled equally, whether the configuration is retrieved programmatically, or via dependency injection.
-The configuration value type is considered a composed type if
-  - the type definition is annotated with the `@ComposedConfig` qualifier
-  - the dependency injection defines the `@ComposedConfig` qualifier
-  - the configuration value is access via the `ConfigAccessor` API and it's dedicated `composed()` method
+The configuration value type is considered a composed type if the type definition is annotated with `@ComposedConfig`.
 
 2. The retrieval of a composed value MUST be performed by a single config source at a time, in order of their defined priority.
 Due to the potential hierarchical nature of composed configuration, the individual sources must define coherent configuration compositions.
@@ -372,5 +369,7 @@ server.sockets.1.port=443
 ----
 
 
-// === Considerations (for EG members)
-// - No prefix attribute added on `@ComposedConfig`, since it arguable doesn't provide much benefits. The injection point has to specify some property name anyway.
+=== Decisions & Considerations (for EG members, to be removed)
+- No prefix attribute added on `@ComposedConfig`, since it arguable doesn't provide much benefits. The injection point has to specify some property name anyway. Discussed on 2018-09-06.
+- Starting with supporting to annotate `@ComposedConfig` on types only, i.e. no qualifier and no annotation on the injection point. Discussed on 2018-09-06.
+- The programmatic `ConfigAccessor` API doesn't require a specific method (such as `composed()`), since the resolution currently requires the composed type to be annotated with `@ComposedConfig`.