Refactor more parts to use new reflection library

Author: thekid

src/main/php/inject/ClassBinding.class.php

@@ -1,26 +1,26 @@
 <?php namespace inject;
 
-use lang\{IllegalArgumentException, XPClass};
+use lang\reflection\{Type, Kind};
+use lang\{IllegalArgumentException, Reflection};
 
 class ClassBinding implements Binding {
-  protected $class;
+  protected $type;
 
   /**
    * Creates a new instance binding
    *
-   * @param  string|lang.XPClass $class
+   * @param  string|lang.XPClass|lang.reflection.Type $class
    * @param  lang.XPClass $type
    * @throws lang.IllegalArgumentException
    */
   public function __construct($class, $type= null) {
-    $c= $class instanceof XPClass ? $class : XPClass::forName($class);
-    if ($type && !$type->isAssignableFrom($c)) {
-      throw new IllegalArgumentException($type.' is not assignable from '.$c);
-    } else if ($c->isInterface() || $c->getModifiers() & MODIFIER_ABSTRACT) {
-      throw new IllegalArgumentException('Cannot bind to non-concrete type '.$type);
-    }
+    $this->type= $class instanceof Type ? $class : Reflection::type($class);
 
-    $this->class= $c;
+    if ($type && !$type->isAssignableFrom($this->type->class())) {
+      throw new IllegalArgumentException($type.' is not assignable from '.$this->type->name());
+    } else if (Kind::$CLASS !== $this->type->kind() || $this->type->modifiers()->isAbstract()) {
+      throw new IllegalArgumentException('Cannot bind to non-concrete type '.$this->type->name());
+    }
   }
 
   /**
@@ -30,7 +30,7 @@ public function __construct($class, $type= null) {
    * @return inject.Provider<?>
    */
   public function provider($injector) {
-    return new TypeProvider($this->class, $injector);
+    return new TypeProvider($this->type, $injector);
   }
 
   /**
@@ -40,6 +40,6 @@ public function provider($injector) {
    * @return var
    */
   public function resolve($injector) {
-    return $injector->newInstance($this->class);
+    return $injector->newInstance($this->type);
   }
 }

src/main/php/inject/ConfiguredBindings.class.php

@@ -1,6 +1,6 @@
 <?php namespace inject;
 
-use lang\{ClassLoader, ClassNotFoundException, ClassCastException};
+use lang\{ClassLoader, ClassNotFoundException, ClassCastException, Reflection};
 use util\{Properties, PropertyAccess};
 
 /**
@@ -130,13 +130,9 @@ private function bindingTo($cl, $namespaces, $input) {
     if (false === ($p= strpos($input, '('))) {
       return $this->resolveType($cl, $namespaces, $input);
     } else {
-      $class= $this->resolveType($cl, $namespaces, substr($input, 0, $p));
-      if ($class->hasConstructor()) {
-        $arguments= eval('return ['.substr($input, $p + 1, -1).'];');
-        return $class->getConstructor()->newInstance($arguments);
-      } else {
-        return $class->newInstance();
-      }
+      $type= $this->resolveType($cl, $namespaces, substr($input, 0, $p));
+      $arguments= eval('return ['.substr($input, $p + 1, -1).'];');
+      return Reflection::type($type)->newInstance(...$arguments);
     }
   }
 

src/main/php/inject/Injector.class.php

@@ -48,7 +48,7 @@ public static function asBinding($t, $impl) {
     } else if (is_array($impl)) {
       return new ArrayBinding($impl, $t);
     } else {
-      return new ClassBinding(XPClass::forName((string)$impl), $t);
+      return new ClassBinding(Reflection::type((string)$impl), $t);
     }
   }
 
@@ -147,19 +147,18 @@ private function argumentsOf($routine, $named= []) {
   /**
    * Implicitely creates an instance binding for a given class.
    *
-   * @param  lang.XPClass $class
+   * @param  lang.reflection.Type $type
    * @param  [:var] $named
    * @return inject.Binding
    * @throws inject.ProvisionException
    */
-  private function instanceOf($class, $named= []) {
-    $t= Reflection::type($class);
-    if (!$t->instantiable(true)) {
-      throw new ProvisionException('Cannot instantiate '.$class->getName().' with non-public constructor');
+  private function instanceOf($type, $named= []) {
+    if (!$type->instantiable(true)) {
+      throw new ProvisionException('Cannot instantiate '.$type->name().' with non-public constructor');
     }
 
-    $constructor= $t->constructor();
-    if (null === $constructor) return new InstanceBinding($class->newInstance());
+    $constructor= $type->constructor();
+    if (null === $constructor) return new InstanceBinding($type->newInstance());
 
     $arguments= $this->argumentsOf($constructor, $named);
     if (!$this->provided($arguments)) return $arguments;
@@ -169,7 +168,7 @@ private function instanceOf($class, $named= []) {
     try {
       return new InstanceBinding($constructor->newInstance($arguments->resolve($this)));
     } catch (Throwable $e) {
-      throw new ProvisionException('Error creating an instance of '.$class->getName(), $e);
+      throw new ProvisionException('Error creating an instance of '.$type->name(), $e);
     }
   }
 
@@ -204,8 +203,9 @@ public function binding($type, $name= null) {
         $literal= $t->literal();
         if ($binding= $this->bindings[$literal][$name] ?? null) {
           return $binding;
-        } else if (null === $name && $t instanceof XPClass && !($t->isInterface() || $t->getModifiers() & MODIFIER_ABSTRACT)) {
-          return $this->instanceOf($t);
+        } else if (null === $name && $t instanceof XPClass) {
+          $type= Reflection::type($t);
+          if ($type->instantiable()) return $this->instanceOf($type);
         }
       }
 
@@ -244,12 +244,13 @@ public function args($routine, $named= []) {
    * injection, the arguments are compiled from the relevant annotations.
    * Otherwise, optional constructor arguments may be passed.
    *
-   * @param   lang.XPClass $class
+   * @param   lang.XPClass|lang.reflection.Type $class
    * @param   [:var] $named Named arguments
    * @return  object
    * @throws  inject.ProvisionException
    */
-  public function newInstance(XPClass $class, $named= []) {
-    return $this->instanceOf($class, $named)->resolve($this);
+  public function newInstance($class, $named= []) {
+    $type= $class instanceof XPClass ? Reflection::type($class) : $class;
+    return $this->instanceOf($type, $named)->resolve($this);
   }
 }

src/main/php/inject/SingletonBinding.class.php

@@ -1,31 +1,30 @@
 <?php namespace inject;
 
-use lang\{IllegalArgumentException, XPClass};
+use lang\reflection\{Type, Kind};
+use lang\{IllegalArgumentException, Reflection};
 
 class SingletonBinding implements Binding {
-  private $class;
+  private $type;
   private $instance= null;
 
   /**
    * Creates a new singleton binding
    *
-   * @param  string|lang.XPClass $class
+   * @param  string|lang.XPClass|lang.reflection.Type $class
    * @throws lang.IllegalArgumentException
    */
   public function __construct($class) {
-    $c= $class instanceof XPClass ? $class : XPClass::forName($class);
-    if ($c->isInterface() || $c->getModifiers() & MODIFIER_ABSTRACT) {
-      throw new IllegalArgumentException('Cannot bind to non-concrete type '.$c);
+    $this->type= $class instanceof Type ? $class : Reflection::type($class);
+    if (Kind::$CLASS !== $this->type->kind() || $this->type->modifiers()->isAbstract()) {
+      throw new IllegalArgumentException('Cannot bind to non-concrete type '.$this->type->name());
     }
-
-    $this->class= $c;
   }
 
   /**
    * Returns a provider for this binding
    *
    * @param  inject.Injector $injector
-   * @param  inject.Provider<?>
+   * @return inject.Provider<?>
    */
   public function provider($injector) {
     return new ResolvingProvider($this, $injector);
@@ -35,9 +34,9 @@ public function provider($injector) {
    * Resolves this binding and returns the instance
    *
    * @param  inject.Injector $injector
-   * @param  var
+   * @return var
    */
   public function resolve($injector) {
-    return $this->instance ?: $this->instance= $injector->newInstance($this->class);
+    return $this->instance ?: $this->instance= $injector->newInstance($this->type);
   }
 }

src/main/php/inject/TypeProvider.class.php

@@ -10,7 +10,7 @@ class TypeProvider implements Provider {
   /**
    * Creates a new type provider
    *
-   * @param  lang.XPClass $type
+   * @param  lang.XPClass|lang.reflection.Type $type
    * @param  inject.Injector $injector
    */
   public function __construct($type, $injector) {