allow vendord

vendor/cuyz/valinor/src/Compiler/Node.php

@@ -0,0 +1,212 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Compiler;
+
+use CuyZ\Valinor\Compiler\Native\AnonymousClassNode;
+use CuyZ\Valinor\Compiler\Native\ArrayNode;
+use CuyZ\Valinor\Compiler\Native\ClassNameNode;
+use CuyZ\Valinor\Compiler\Native\ClassNode;
+use CuyZ\Valinor\Compiler\Native\ClosureNode;
+use CuyZ\Valinor\Compiler\Native\ComplianceNode;
+use CuyZ\Valinor\Compiler\Native\ExpressionNode;
+use CuyZ\Valinor\Compiler\Native\ForEachNode;
+use CuyZ\Valinor\Compiler\Native\FunctionCallNode;
+use CuyZ\Valinor\Compiler\Native\IfNode;
+use CuyZ\Valinor\Compiler\Native\LogicalAndNode;
+use CuyZ\Valinor\Compiler\Native\LogicalOrNode;
+use CuyZ\Valinor\Compiler\Native\MatchNode;
+use CuyZ\Valinor\Compiler\Native\MethodNode;
+use CuyZ\Valinor\Compiler\Native\NegateNode;
+use CuyZ\Valinor\Compiler\Native\NewClassNode;
+use CuyZ\Valinor\Compiler\Native\ParameterDeclarationNode;
+use CuyZ\Valinor\Compiler\Native\PropertyDeclarationNode;
+use CuyZ\Valinor\Compiler\Native\PropertyNode;
+use CuyZ\Valinor\Compiler\Native\ReturnNode;
+use CuyZ\Valinor\Compiler\Native\ShortClosureNode;
+use CuyZ\Valinor\Compiler\Native\TernaryNode;
+use CuyZ\Valinor\Compiler\Native\ThrowNode;
+use CuyZ\Valinor\Compiler\Native\ValueNode;
+use CuyZ\Valinor\Compiler\Native\VariableNode;
+use CuyZ\Valinor\Compiler\Native\WrapNode;
+use CuyZ\Valinor\Compiler\Native\YieldNode;
+
+/** @internal */
+abstract class Node
+{
+    abstract public function compile(Compiler $compiler): Compiler;
+
+    public function asExpression(): ExpressionNode
+    {
+        return new ExpressionNode($this);
+    }
+
+    public function wrap(): ComplianceNode
+    {
+        return new ComplianceNode(new WrapNode($this));
+    }
+
+    /**
+     * @param array<Node> $assignments
+     */
+    public static function array(array $assignments = []): ArrayNode
+    {
+        return new ArrayNode($assignments);
+    }
+
+    public static function anonymousClass(): AnonymousClassNode
+    {
+        return new AnonymousClassNode();
+    }
+
+    /**
+     * @param class-string $name
+     */
+    public static function class(string $name): ClassNode
+    {
+        return new ClassNode($name);
+    }
+
+    /**
+     * @param class-string $className
+     */
+    public static function className(string $className): ClassNameNode
+    {
+        return new ClassNameNode($className);
+    }
+
+    public static function closure(Node ...$nodes): ClosureNode
+    {
+        return new ClosureNode(...$nodes);
+    }
+
+    /**
+     * @param non-empty-string $key
+     * @param non-empty-string $item
+     */
+    public static function forEach(Node $value, string $key, string $item, Node $body): ForEachNode
+    {
+        return new ForEachNode($value, $key, $item, $body);
+    }
+
+    /**
+     * @param non-empty-string $name
+     * @param array<Node> $arguments
+     */
+    public static function functionCall(string $name, array $arguments = []): ComplianceNode
+    {
+        return new ComplianceNode(new FunctionCallNode($name, $arguments));
+    }
+
+    public static function if(Node $condition, Node $body): IfNode
+    {
+        return new IfNode($condition, $body);
+    }
+
+    /**
+     * @no-named-arguments
+     */
+    public static function logicalAnd(Node ...$nodes): ComplianceNode
+    {
+        return new ComplianceNode(new LogicalAndNode(...$nodes));
+    }
+
+    /**
+     * @no-named-arguments
+     */
+    public static function logicalOr(Node ...$nodes): ComplianceNode
+    {
+        return new ComplianceNode(new LogicalOrNode(...$nodes));
+    }
+
+    public static function match(Node $value): MatchNode
+    {
+        return new MatchNode($value);
+    }
+
+    /**
+     * @param non-empty-string $name
+     */
+    public static function method(string $name): MethodNode
+    {
+        return new MethodNode($name);
+    }
+
+    public static function negate(Node $node): NegateNode
+    {
+        return new NegateNode($node);
+    }
+
+    /**
+     * @param class-string $className
+     */
+    public static function newClass(string $className, Node ...$arguments): NewClassNode
+    {
+        return new NewClassNode($className, ...$arguments);
+    }
+
+    /**
+     * @param non-empty-string $name
+     */
+    public static function parameterDeclaration(string $name, string $type): ParameterDeclarationNode
+    {
+        return new ParameterDeclarationNode($name, $type);
+    }
+
+    public static function property(string $name): ComplianceNode
+    {
+        return new ComplianceNode(new PropertyNode($name));
+    }
+
+    /**
+     * @param non-empty-string $name
+     */
+    public static function propertyDeclaration(string $name, string $type): PropertyDeclarationNode
+    {
+        return new PropertyDeclarationNode($name, $type);
+    }
+
+    public static function return(Node $node): ReturnNode
+    {
+        return new ReturnNode($node);
+    }
+
+    public static function shortClosure(Node $return): ShortClosureNode
+    {
+        return new ShortClosureNode($return);
+    }
+
+    public static function ternary(Node $condition, Node $ifTrue, Node $ifFalse): TernaryNode
+    {
+        return new TernaryNode($condition, $ifTrue, $ifFalse);
+    }
+
+    public static function this(): ComplianceNode
+    {
+        return self::variable('this');
+    }
+
+    public static function throw(Node $node): ThrowNode
+    {
+        return new ThrowNode($node);
+    }
+
+    /**
+     * @param array<mixed>|bool|float|int|string|null $value
+     */
+    public static function value(array|bool|float|int|string|null $value): ComplianceNode
+    {
+        return new ComplianceNode(new ValueNode($value));
+    }
+
+    public static function variable(string $name): ComplianceNode
+    {
+        return new ComplianceNode(new VariableNode($name));
+    }
+
+    public static function yield(Node $key, Node $value): YieldNode
+    {
+        return new YieldNode($key, $value);
+    }
+}