Better type tests around instantiation and validation scenarios

These added tests verify that:

 * `Enum::assert*` methods can be used in a pure form
 * `Enum::from*` methods can be used in a pure form
 * `Enum#__construct()` properly binds the instance type of the enumerable with the input value
 * `Enum::assert*` methods currently **CANNOT** bind the input to an enumerable potential value (BUG)
 * `Enum::from*` methods currently **CANNOT** bind the input to an enumerable potential value (BUG)

In addition to that, `psalm.xml` has been made a bit stricter:

 * `resolveFromConfigFile` was removed (we were using the default value)
 * `findUnusedPsalmSuppress` was added, allowing us to find whether intentional suppressions are now
    invalid. This allows us to verify negative scenarios, in which we **expect** a type error to appear
 * `restrictReturnTypes` better refines templated types, requiring inputs/outputs to match for those too

Author: Ocramius

psalm.xml

@@ -1,10 +1,11 @@
 <?xml version="1.0"?>
 <psalm
-    totallyTyped="true"
-    resolveFromConfigFile="true"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="https://getpsalm.org/schema/config"
     xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    restrictReturnTypes="true"
+    findUnusedPsalmSuppress="true"
+    totallyTyped="true"
 >
     <projectFiles>
         <directory name="src" />
@@ -16,8 +17,6 @@
     </projectFiles>
 
     <issueHandlers>
-        <MixedAssignment errorLevel="info" />
-
         <ImpureStaticProperty>
             <!-- self::$... usages in Enum are used to populate an internal cache, and cause no side-effects -->
             <errorLevel type="suppress">

static-analysis/EnumInstantiation.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MyCLabs\Tests\Enum\StaticAnalysis;
+
+use MyCLabs\Enum\Enum;
+
+/**
+ * @psalm-immutable
+ * @psalm-template T of 'A'|'C'
+ * @template-extends Enum<T>
+ */
+final class InstantiatedEnum extends Enum
+{
+    const A = 'A';
+    const C = 'C';
+}
+
+/**
+ * @psalm-pure
+ * @psalm-return InstantiatedEnum<'A'>
+ */
+function canCallConstructorWithConstantValue(): InstantiatedEnum
+{
+    return new InstantiatedEnum('A');
+}
+
+/**
+ * @psalm-pure
+ * @psalm-return InstantiatedEnum<'C'>
+ */
+function canCallConstructorWithConstantReference(): InstantiatedEnum
+{
+    return new InstantiatedEnum(InstantiatedEnum::C);
+}
+
+/** @psalm-pure */
+function canCallFromWithKnownValue(): InstantiatedEnum
+{
+    return InstantiatedEnum::from('C');
+}
+
+/** @psalm-pure */
+function canCallFromWithUnknownValue(): InstantiatedEnum
+{
+    return InstantiatedEnum::from(123123);
+}

static-analysis/EnumIsPure.php

@@ -11,7 +11,7 @@
  * @method static PureEnum C()
  *
  * @psalm-immutable
- * @psalm-template T of 'A'|'B'
+ * @psalm-template T of 'A'|'C'
  * @template-extends Enum<T>
  */
 final class PureEnum extends Enum

static-analysis/EnumValidation.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MyCLabs\Tests\Enum\StaticAnalysis;
+
+use MyCLabs\Enum\Enum;
+
+/**
+ * @psalm-immutable
+ * @psalm-template T of 'A'|'C'
+ * @template-extends Enum<T>
+ */
+final class ValidationEnum extends Enum
+{
+    const A = 'A';
+    const C = 'C';
+}
+
+/**
+ * @psalm-pure
+ * @param mixed $input
+ * @psalm-return 'A'|'C'
+ *
+ * @psalm-suppress MixedReturnStatement
+ * @psalm-suppress MixedInferredReturnType at the time of this writing, we did not yet find
+ *                                         a proper approach to constraint input values through
+ *                                         validation via static methods.
+ */
+function canValidateValue($input): string
+{
+    ValidationEnum::assertValidValue($input);
+
+    return $input;
+}
+
+/**
+ * @psalm-pure
+ * @param mixed $input
+ * @psalm-return 'A'|'C'
+ *
+ * @psalm-suppress MixedReturnStatement
+ * @psalm-suppress MixedInferredReturnType at the time of this writing, we did not yet find
+ *                                         a proper approach to constraint input values through
+ *                                         validation via static methods.
+ */
+function canValidateValueThroughIsValid($input): string
+{
+    if (! ValidationEnum::isValid($input)) {
+        throw new \InvalidArgumentException('Value not valid');
+    }
+
+    return $input;
+}