Initial release

Based on xp-framework/compiler#68

Author: thekid

.travis.yml

@@ -0,0 +1,26 @@
+# xp-lang/php-is-operator
+
+language: php
+
+dist: trusty
+
+php:
+  - 7.0
+  - 7.1
+  - 7.2
+  - 7.3
+  - 7.4snapshot
+  - nightly
+
+matrix:
+  allow_failures:
+    - php: nightly
+
+before_script:
+  - curl -sSL https://dl.bintray.com/xp-runners/generic/xp-run-8.1.7.sh > xp-run
+  - composer install --prefer-dist
+  - echo "vendor/autoload.php" > composer.pth
+  - echo "vendor/xp-framework/compiler/src/test/php" >> composer.pth
+
+script:
+  - sh xp-run xp.unittest.TestRunner src/test/php

ChangeLog.md

@@ -0,0 +1,8 @@
+Is operator for PHP - ChangeLog
+===============================
+
+## ?.?.? / ????-??-??
+
+## 0.1.0 / 2019-09-09
+
+* Hello World! First release - @thekid

README.md

@@ -0,0 +1,58 @@
+Is operator for PHP
+===================
+
+[![Build Status on TravisCI](https://secure.travis-ci.org/xp-lang/php-is-operator.svg)](http://travis-ci.org/xp-lang/php-is-operator)
+[![XP Framework Module](https://raw.githubusercontent.com/xp-framework/web/master/static/xp-framework-badge.png)](https://github.com/xp-framework/core)
+[![BSD Licence](https://raw.githubusercontent.com/xp-framework/web/master/static/licence-bsd.png)](https://github.com/xp-framework/core/blob/master/LICENCE.md)
+[![Supports PHP 7.0+](https://raw.githubusercontent.com/xp-framework/web/master/static/php-7_0plus.png)](http://php.net/)
+[![Latest Stable Version](https://poser.pugx.org/xp-lang/php-is-operator/version.png)](https://packagist.org/packages/xp-lang/php-is-operator)
+
+Plugin for the [XP Compiler](https://github.com/xp-framework/compiler/) which adds switch expressions to the PHP language.
+
+Before
+------
+A mix of functions, syntax and XP core functionality `is()`:
+
+```php
+is_string($value)                                  // for primitives, use is_[T]()
+is_callable($value)                                // for pseudo types callable, array, object
+is_array($value) || $value instanceof \Traversable // no is_iterable in PHP 5 and 7.0 
+$value instanceof Date                             // for value types
+null === $value || is_int($value)                  // nullable types cannot be tested directly
+is('[:string]', $value)                            // for types beyond PHP type system
+is('string|util.URI', $value)                      // for types beyond PHP type system
+```
+
+After
+-----
+Anything that works as a parameter, property or return type can be used with the `is` operator.
+
+```php
+$value is string
+$value is callable
+$value is iterable
+$value is Date
+$value is ?int
+$value is array<string, string>
+$value is string|URI
+```
+
+Installation
+------------
+After installing the XP Compiler into your project, also include this plugin.
+
+```bash
+$ composer require xp-framework/compiler
+# ...
+
+$ composer require xp-lang/php-is-operator
+# ...
+```
+
+No further action is required.
+
+See also
+--------
+* https://docs.hhvm.com/hack/expressions-and-operators/is
+* https://kotlinlang.org/docs/reference/typecasts.html
+* https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/is

class.pth

@@ -0,0 +1,2 @@
+src/main/php/
+src/test/php/

composer.json

@@ -0,0 +1,19 @@
+{
+  "name" : "xp-lang/php-is-operator",
+  "type" : "library",
+  "homepage" : "http://xp-framework.net/",
+  "license" : "BSD-3-Clause",
+  "description" : "Is operator for PHP",
+  "keywords": ["language", "module", "xp"],
+  "require" : {
+    "xp-framework/core": "^9.0 | ^8.0",
+    "xp-framework/compiler": "^4.0",
+    "php" : ">=7.0.0"
+  },
+  "require-dev" : {
+    "xp-framework/unittest": "^9.0 | ^8.0"
+  },
+  "autoload" : {
+    "files" : ["src/main/php/autoload.php"]
+  }
+}

src/main/php/autoload.php

@@ -0,0 +1,3 @@
+<?php namespace xp;
+
+\lang\ClassLoader::registerPath(__DIR__);

src/main/php/lang/ast/syntax/php/IsOperator.class.php

@@ -0,0 +1,67 @@
+<?php namespace lang\ast\syntax\php;
+
+use lang\ast\ArrayType;
+use lang\ast\FunctionType;
+use lang\ast\MapType;
+use lang\ast\Node;
+use lang\ast\UnionType;
+use lang\ast\nodes\BinaryExpression;
+use lang\ast\nodes\InstanceOfExpression;
+use lang\ast\nodes\InvokeExpression;
+use lang\ast\nodes\Literal;
+use lang\ast\syntax\Extension;
+
+class IsOperator implements Extension {
+
+  public function setup($language, $emitter) {
+    $language->infix('is', 60, function($parse, $token, $left) {
+      $t= $this->type($parse, true);
+
+      $node= new InstanceOfExpression($left, $t ?: $this->expression($parse, 0));
+      $node->kind= 'is';
+      return $node;
+    });
+
+    $test= function($literal, $expr) {
+      static $is= [
+        'string'   => true,
+        'int'      => true,
+        'float'    => true,
+        'bool'     => true,
+        'array'    => true,
+        'object'   => true,
+        'iterable' => true,
+        'callable' => true
+      ];
+
+      if (isset($is[$literal])) {
+        return new InvokeExpression(new Literal('is_'.$literal), [$expr]);
+      } else {
+        return new InstanceOfExpression($expr, new Literal($literal));
+      }
+    };
+
+    $emitter->transform('is', function($codegen, $node) use($test) {
+      $t= $node->type;
+      if ($t instanceof Node) {
+        return new InvokeExpression(new Literal('is'), [$node->type, $node->expression]);
+      }
+
+      // Verify builtin primitives with is_XXX(), value types with instanceof, others using is()
+      if ($t instanceof FunctionType || $t instanceof ArrayType || $t instanceof MapType || $t instanceof UnionType) {
+        return new InvokeExpression(new Literal('is'), [new Literal('"'.$t->name().'"'), $node->expression]);
+      } else {
+        $literal= $t->literal();
+        if ('?' === $literal[0]) {
+          return new BinaryExpression(
+            new BinaryExpression(new Literal('null'), '===', $node->expression),
+            '||',
+            $test(substr($literal, 1), $node->expression)
+          );
+        } else {
+          return $test($literal, $node->expression);
+        }
+      }
+    });
+  }
+}

src/test/php/lang/ast/syntax/php/unittest/IsOperatorTest.class.php

@@ -0,0 +1,199 @@
+<?php namespace lang\ast\syntax\php\unittest;
+
+use lang\ast\unittest\emit\EmittingTest;
+
+class IsOperatorTest extends EmittingTest {
+
+  #[@test]
+  public function this_is_self() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return $this is self;
+      }
+    }');
+
+    $this->assertTrue($r);
+  }
+
+  #[@test]
+  public function new_self_is_static() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return new self() is static;
+      }
+    }');
+
+    $this->assertTrue($r);
+  }
+
+  #[@test]
+  public function is_qualified_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return new \util\Date() is \util\Date;
+      }
+    }');
+
+    $this->assertTrue($r);
+  }
+
+  #[@test]
+  public function is_imported_type() {
+    $r= $this->run('use util\Date; class <T> {
+      public function run() {
+        return new Date() is Date;
+      }
+    }');
+
+    $this->assertTrue($r);
+  }
+
+  #[@test]
+  public function is_aliased_type() {
+    $r= $this->run('use util\Date as D; class <T> {
+      public function run() {
+        return new D() is D;
+      }
+    }');
+
+    $this->assertTrue($r);
+  }
+
+  #[@test]
+  public function is_type_variable() {
+    $r= $this->run('class <T> {
+      public function run() {
+        $type= self::class;
+        return new self() is $type;
+      }
+    }');
+
+    $this->assertTrue($r);
+  }
+
+  #[@test]
+  public function is_primitive_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [1 is int, true is bool, -6.1 is float, 6.1 is float, "test" is string];
+      }
+    }');
+
+    $this->assertEquals([true, true, true, true, true], $r);
+  }
+
+  #[@test]
+  public function is_nullable_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [null is ?int, null is ?self, $this is ?self];
+      }
+    }');
+
+    $this->assertEquals([true, true, true], $r);
+  }
+
+  #[@test]
+  public function is_array_pseudo_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [[] is array, [1, 2, 3] is array, ["key" => "value"] is array, null is array];
+      }
+    }');
+
+    $this->assertEquals([true, true, true, false], $r);
+  }
+
+  #[@test]
+  public function is_object_pseudo_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [$this is object, function() { } is object, null is object];
+      }
+    }');
+
+    $this->assertEquals([true, true, false], $r);
+  }
+
+  #[@test]
+  public function is_callable_pseudo_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [function() { } is callable, [$this, "run"] is callable, null is callable];
+      }
+    }');
+
+    $this->assertEquals([true, true, false], $r);
+  }
+
+  #[@test]
+  public function is_native_iterable_type() {
+    $r= $this->run('class <T> implements \IteratorAggregate {
+      public function getIterator() {
+        yield 1;
+      }
+
+      public function run() {
+        return [[] is iterable, $this is iterable, null is iterable];
+      }
+    }');
+
+    $this->assertEquals([true, true, false], $r);
+  }
+
+  #[@test]
+  public function is_map_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [["key" => "value"] is array<string, string>, null is array<string, string>];
+      }
+    }');
+
+    $this->assertEquals([true, false], $r);
+  }
+
+  #[@test]
+  public function is_array_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [["key"] is array<string>, ["key"] is array<int>, null is array<string>];
+      }
+    }');
+
+    $this->assertEquals([true, false, false], $r);
+  }
+
+  #[@test]
+  public function is_union_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [1 is int|string, "test" is int|string, null is int|string];
+      }
+    }');
+
+    $this->assertEquals([true, true, false], $r);
+  }
+
+  #[@test]
+  public function is_function_type() {
+    $r= $this->run('class <T> {
+      public function run() {
+        return [function(int $a): int { } is function(int): int, null is function(int): int];
+      }
+    }');
+
+    $this->assertEquals([true, false], $r);
+  }
+
+  #[@test]
+  public function precedence() {
+    $r= $this->run('class <T> {
+      public function run() {
+        $arg= "Test";
+        return $arg is string ? sprintf("string <%s>", $arg) : typeof($arg)->literal();
+      }
+    }');
+
+    $this->assertEquals('string <Test>', $r);
+  }
+}