Convert submodule to regular files for release

Author: actions-user

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "phpstorm-attributes"]
-	path = meta/attributes/public
-	url = [email protected]:JetBrains/phpstorm-attributes.git
-	branch = master

meta/attributes/public

@@ -0,0 +1,23 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * The attribute specifies possible array keys and their types.
+ *
+ * If applied, an IDE will suggest the specified array keys, infer the specified types, and highlight non-specified keys in array access expressions.
+ *
+ * Array shapes should be specified with the required $shape parameter whose values should be array literals.<br />
+ *
+ * Example: <br />
+ * <b>#[ArrayShape(["f" => "int", "string", "x" => "float"])]</b>
+ * This usage applied on an element effectively means that the array has 3 dimensions, the keys are "f", 1, and "x", and the corresponding types are "int", "string", and "float".
+ */
+#[Attribute(Attribute::TARGET_FUNCTION | Attribute::TARGET_METHOD | Attribute::TARGET_PARAMETER | Attribute::TARGET_PROPERTY)]
+class ArrayShape {
+    public function __construct(array $shape)
+    {
+    }
+}

meta/attributes/public/ArrayShape.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_FUNCTION | Attribute::TARGET_METHOD | Attribute::TARGET_CLASS | Attribute::TARGET_CLASS_CONSTANT | Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+class Deprecated {
+    public const PHP_VERSIONS = [
+        "5.3",
+        "5.4",
+        "5.5",
+        "5.6",
+        "7.0",
+        "7.1",
+        "7.2",
+        "7.3",
+        "7.4",
+        "8.0",
+        "8.1",
+        "8.2",
+        "8.3",
+        "8.4",
+    ];
+
+    /**
+     * Mark element as deprecated
+     *
+     * @param string $reason Reason for deprecation. It will be displayed by PhpStorm via the Deprecated inspection instead of the  default message
+     * @param string $replacement Applicable only to function/method calls: IDE will suggest replacing a deprecated function call with the provided code template.
+     * The following variables are available in this template:
+     * <ul>
+     * <li>%parametersList%: parameters of the function call. For example, for the "f(1,2)" call, %parametersList% will be "1,2"</li>
+     * <li>%parameter0%,%parameter1%,%parameter2%,...: parameters of the function call. For example, for the "f(1,2)" call, %parameter1% will be "2"</li>
+     * <li>%name%: For "\x\f(1,2)", %name% will be "\x\f", for "$this->ff()", %name% will be "ff"</li>
+     * <li>%class%: If the attribute is provided for method "m", then for "$this->f()->m()", %class% will be "$this->f()"</li>
+     * </ul>
+     * The following example shows how to wrap a function call in another call and swap arguments:<br />
+     * "#[Deprecated(replacement: "wrappedCall(%name%(%parameter1%, %parameter0%))")] f($a, $b){}<br />
+     * f(1,2) will be replaced with wrappedCall(f(2,1))
+     * @param string $since Element is deprecated starting with the provided PHP language level, applicable only for PhpStorm stubs entries
+     */
+    public function __construct($reason = "", $replacement = "",
+                                #[ExpectedValues(self::PHP_VERSIONS)] $since = "5.6")
+    {
+    }
+}

meta/attributes/public/Deprecated.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * The attribute specifies the expected values of an entity: return values for functions and arguments' values for methods.
+ *
+ * If the attribute is applied, PhpStorm assumes that only the arguments specified in the attribute constructor can
+ * be passed/returned. This will affect the following:
+ * <ul>
+ * <li><i>Code completion</i> - expected arguments are displayed on the top of the suggestions list when used in comparison expressions</li>
+ * <li><i>Inspections [when used in a comparison with a value/assignment to/return from method]</i> - the element absent from the expected values list produces the inspection warning</li>
+ * <li><i>Code generation</i> - for example, when generating the 'switch' statement, all possible expected values are inserted automatically</li>
+ * </ul>
+ *
+ * Expected values can be any of the following:
+ * <ul>
+ * <li>numbers</li>
+ * <li>string literals</li>
+ * <li>constant references</li>
+ * <li>class constant references</li>
+ * </ul>
+ *
+ * Expected arguments can be specified in any of the following ways:
+ * <ul>
+ * <li><b>#[ExpectedValues(values: [1,2,3])]</b> means that one of the following is expected: `1`, `2`, or `3`</li>
+ * <li><b>#[ExpectedValues(values: MY_CONST]</b> - default value of MY_CONST is expected to be array creation expression, in this case value of MY_CONST will be inlined</li>
+ * <li><b>#[ExpectedValues(flags: [1,2,3])]</b> means that a bitmask of the following is expected: `1`, `2`, or `3`</li>
+ * <li><b>#[ExpectedValues(valuesFromClass: MyClass::class)]</b> means that one of the constants from the class `MyClass` is expected</li>
+ * <li><b>#[ExpectedValues(flagsFromClass: ExpectedValues::class)]</b> means that a bitmask of the constants from the class `MyClass` is expected</li>
+ * </ul>
+ *
+ * The attribute with the number of provided constructor arguments different from 1 will result in undefined behavior.
+ * @since 8.0
+ */
+#[Attribute(Attribute::TARGET_FUNCTION | Attribute::TARGET_METHOD | Attribute::TARGET_PARAMETER | Attribute::TARGET_PROPERTY)]
+class ExpectedValues {
+    public function __construct(array $values = [], array $flags = [], ?string $valuesFromClass = null, ?string $flagsFromClass = null)
+    {
+    }
+}

meta/attributes/public/ExpectedValues.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * Mark a property (or all class properties in the case of a class) as immutable.
+ * By default, an IDE highlights write accesses on such properties if they are located outside a constructor (this scope is customizable, see below).
+ *
+ * You can provide a custom allowed write scope by using the following values:
+ * <ul>
+ * <li>{@link Immutable::CONSTRUCTOR_WRITE_SCOPE}: write is allowed only in containing class constructor (default choice)</li>
+ * <li>{@link Immutable::PRIVATE_WRITE_SCOPE}: write is allowed only in places where the property would be accessible if it had 'private' visibility modifier</li>
+ * <li>{@link Immutable::PROTECTED_WRITE_SCOPE}: write is allowed only in places where the property would be accessible if it had 'protected' visibility modifier</li>
+ * </ul>
+ * @since 8.0
+ */
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS)]
+class Immutable
+{
+    const CONSTRUCTOR_WRITE_SCOPE = "constructor";
+    const PRIVATE_WRITE_SCOPE = "private";
+    const PROTECTED_WRITE_SCOPE = "protected";
+
+    public function __construct(#[ExpectedValues(valuesFromClass: Immutable::class)]
+                                $allowedWriteScope = self::CONSTRUCTOR_WRITE_SCOPE)
+    {
+    }
+}

meta/attributes/public/Immutable.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * Specifies that the parameter is a string that represents source code in a different language.
+ * An IDE will automatically inject the specified language into the passed string literals.
+ *
+ * @since 8.0
+ */
+#[Attribute(Attribute::TARGET_PARAMETER)]
+class Language {
+    /**
+     * @param string $languageName Language name like "PHP", "SQL", "RegExp", etc...
+     */
+    public function __construct(string $languageName)
+    {
+    }
+}

meta/attributes/public/Language.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * You can use this facility to mark the function as halting the execution flow.
+ * Such marked functions will be treated like die() or exit() calls by control flow inspections.
+ * In most cases, just annotation function with 0 arguments will work.
+ * To mark the function as the exit point only when it's called with some constant arguments, specify them in $arguments param
+ *
+ * {@see NoReturn::ANY_ARGUMENT}
+ */
+#[Attribute(Attribute::TARGET_FUNCTION | Attribute::TARGET_METHOD)]
+class NoReturn {
+    /**
+     * Use this constant to skip function argument on the specified position
+     */
+    public const ANY_ARGUMENT = 1;
+
+    public function __construct(...$arguments)
+    {
+    }
+}

meta/attributes/public/NoReturn.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * The attribute specifies possible object field names and their types.
+ *
+ * If applied, an IDE will suggest the specified field names and infer the specified types.
+ *
+ * Example:
+ * <pre>#[ObjectShape(["age" => "int", "name" => "string"])]</pre>
+ *
+ * This usage applied on an element effectively means that the object has 2 fields, the names are <code>"age"</code> and <code>"name"</code>, and the corresponding types are <code>"int"</code> and <code>"string"</code>.
+ */
+#[Attribute(Attribute::TARGET_FUNCTION|Attribute::TARGET_METHOD|Attribute::TARGET_PARAMETER|Attribute::TARGET_PROPERTY)]
+class ObjectShape
+{
+    public function __construct(array $shape) {}
+}

meta/attributes/public/ObjectShape.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace JetBrains\PhpStorm;
+
+use Attribute;
+
+/**
+ * The attribute marks the function that has no impact on the program state or passed parameters used after the function execution.
+ * This means that a function call that resolves to such a function can be safely removed if the execution result is not used in code afterwards.
+ *
+ * @since 8.0
+ */
+#[Attribute(Attribute::TARGET_FUNCTION | Attribute::TARGET_METHOD)]
+class Pure
+{
+    /**
+     * @param bool $mayDependOnGlobalScope Whether the function result may be dependendent on anything except passed variables
+     */
+    public function __construct(bool $mayDependOnGlobalScope = false)
+    {
+    }
+}