Implement values as complement to annotations

See xp-framework/rfc#336, values are key/value pairs that can be
attached to types and type members. They serve as a complement to
PHP 8 attributes which do not support arbitrary expressions in
their argument lists.

src/main/php/lang/ast/Tokens.class.php

@@ -137,6 +137,8 @@ public function getIterator() {
  $offset-= strlen($t);
  yield 'operator' => ['#[', $line];
  }
+ } else if ('$' === $t) {
+ yield 'operator' => ['#$', $line];
  } else {
  yield 'comment' => ['#'.$t.$next("\r\n"), $line];
  }

src/main/php/lang/ast/nodes/Annotated.class.php

@@ -3,7 +3,7 @@
 use lang\ast\Node;
 
 abstract class Annotated extends Node {
- public $annotations;
+ public $annotations, $values;
 
  /**
  * Returns an annotation for a given name, or NULL if no annotation

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

@@ -66,6 +66,10 @@
 class PHP extends Language {
  private $body= [];
 
+ static function __static() {
+ define('DETAIL_VALUES', 0x100);
+ }
+
  /** Setup language parser */
  public function __construct() {
  $this->symbol(':');
@@ -808,6 +812,16 @@ public function __construct() {
  return $type;
  });
 
+ $this->stmt('#$', function($parse, $token) {
+ $name= $parse->token->value;
+ $parse->forward();
+ $parse->expecting(':', 'value');
+ $value= $this->expression($parse, 0);
+ $type= $this->statement($parse);
+ $type->values[$name]= $value;
+ return $type;
+ });
+
  $this->stmt('class', function($parse, $token) {
  $type= $parse->scope->resolve($parse->token->value);
  $parse->forward();
@@ -944,6 +958,7 @@ public function __construct() {
  $line
  );
  $body[$name]->holder= $holder;
+ $body[$name]->values= $meta[DETAIL_VALUES] ?? null;
  if (',' === $parse->token->value) {
  $parse->forward();
  }
@@ -992,6 +1007,7 @@ public function __construct() {
  $line
  );
  $body[$lookup]->holder= $holder;
+ $body[$lookup]->values= $meta[DETAIL_VALUES] ?? null;
  });
  }
 
@@ -1114,6 +1130,7 @@ private function properties($parse, &$body, $meta, $modifiers, $type, $holder) {
  }
  $body[$lookup]= new Property($modifiers, $name, $type, $expr, $annotations, $comment, $line);
  $body[$lookup]->holder= $holder;
+ $body[$lookup]->values= $meta[DETAIL_VALUES] ?? null;
 
  if (',' === $parse->token->value) {
  $parse->forward();
@@ -1353,6 +1370,13 @@ public function typeBody($parse, $holder) {
  } else if ('#[' === $parse->token->value) {
  $parse->forward();
  $meta= [DETAIL_ANNOTATIONS => $this->attributes($parse, 'member attributes')];
+ } else if ('#$' === $parse->token->value) {
+ $parse->forward();
+ $name= $parse->token->value;
+ $parse->forward();
+ $parse->expecting(':', 'value');
+ $value= $this->expression($parse, 0);
+ $meta[DETAIL_VALUES][$name]= $value;
  } else if ('#[@' === $parse->token->value) {
  $parse->forward();
  $meta= $this->meta($parse, 'member annotations');

src/test/php/lang/ast/unittest/parse/ValuesTest.class.php

@@ -0,0 +1,83 @@
+<?php namespace lang\ast\unittest\parse;
+
+use lang\ast\nodes\{Annotated, Literal, LambdaExpression};
+use unittest\Assert;
+
+/** @see https://github.com/xp-framework/rfc/issues/336 */
+class ValuesTest extends ParseTest {
+
+ /**
+ * Parses source into type
+ *
+ * @param string $source
+ * @return lang.ast.TypeDeclaration
+ */
+ private function type($source) {
+ return $this->parse($source)->tree()->type('T');
+ }
+
+ /**
+ * Assertion helper
+ *
+ * @param var $expected
+ * @param lang.ast.Node $node
+ * @throws unittest.AssertionFailedError
+ * @return void
+ */
+ private function assertValues($expected, $node) {
+ Assert::equals($expected, cast($node, Annotated::class)->values);
+ }
+
+ #[@test]
+ public function on_class() {
+ $this->assertValues(
+ ['using' => new Literal('"value"', self::LINE)],
+ $this->type('#$using: "value" class T { }')
+ );
+ }
+
+ #[@test]
+ public function on_constant() {
+ $this->assertValues(
+ ['using' => new Literal('"value"', self::LINE)],
+ $this->type('class T { #$using: "value" const FIXTURE = "test"; }')->constant('FIXTURE')
+ );
+ }
+
+ #[@test]
+ public function on_property() {
+ $this->assertValues(
+ ['using' => new Literal('"value"', self::LINE)],
+ $this->type('class T { #$using: "value" public $fixture; }')->property('fixture')
+ );
+ }
+
+ #[@test]
+ public function on_method() {
+ $this->assertValues(
+ ['using' => new Literal('"value"', self::LINE)],
+ $this->type('class T { #$using: "value" public function fixture() { } }')->method('fixture')
+ );
+ }
+
+ #[@test]
+ public function values_on_multiple_lines() {
+ $this->assertValues(
+ ['author' => new Literal('"test"', self::LINE + 1), 'version' => new Literal('1', self::LINE + 2)],
+ $this->type('
+ #$author: "test"
+ #$version: 1
+ class T { }
+ ')
+ );
+ }
+
+ #[@test]
+ public function with_function() {
+ $type= $this->type('
+ #$using: fn() => version_compare(PHP_VERSION, "7.0.0", ">=")
+ class T { }
+ ');
+ Assert::instance(LambdaExpression::class, cast($type, Annotated::class)->values['using']);
+ }
+}