Add attributes to ClassMethod abstraction

src/Checks/ClassConstCheck.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace BambooHR\Guardrail\Checks;
+
+use BambooHR\Guardrail\Output\OutputInterface;
+use BambooHR\Guardrail\Scope;
+use BambooHR\Guardrail\SymbolTable\SymbolTable;
+use BambooHR\Guardrail\TypeComparer;
+use PhpParser\Node;
+use PhpParser\Node\Stmt\ClassConst;
+use PhpParser\Node\Stmt\ClassLike;
+
+class ClassConstCheck extends BaseCheck {
+	private $comparer;
+	function __construct(SymbolTable $symbolTable, OutputInterface $doc) {
+		parent::__construct($symbolTable, $doc);
+		$this->comparer=new TypeComparer($symbolTable);
+	}
+
+	function getCheckNodeTypes() {
+		return [ClassConst::class];
+	}
+
+	function run($fileName, Node $node, ClassLike $inside = null, Scope $scope = null) {
+		if ($node instanceof ClassConst) {
+			foreach($node->consts as $const) {
+				/** @var Node\Const_ $const */
+				$constValue = $const->value->getAttribute(TypeComparer::INFERRED_TYPE_ATTR );
+				if ($node->type && $constValue) {
+					if (!$this->comparer->isCompatibleWithTarget($node->type, $constValue, $scope)) {
+						$this->emitError($fileName, $node, ErrorConstants::TYPE_CONST_TYPE,
+							 "Type mismatch between declared type and constant value " .
+							 TypeComparer::typeToString($node->type) . " vs " .
+							 TypeComparer::typeToString($constValue)
+						);
+					}
+				}
+			}
+		}
+	}
+}

src/Checks/ErrorConstants.php

@@ -51,6 +51,7 @@ class ErrorConstants {
 	const TYPE_SIGNATURE_COUNT_EXCESS = 'Standard.Param.Count.Excess';
 	const TYPE_SIGNATURE_RETURN = 'Standard.Return.Type';
 	const TYPE_SIGNATURE_TYPE = 'Standard.Param.Type';
+	const TYPE_CONST_TYPE = 'Standard.Const.Type';
 	const TYPE_SIGNATURE_TYPE_NULL = "Standard.Null.Param";
 	const TYPE_UNIMPLEMENTED_METHOD = 'Standard.Inheritance.Unimplemented';
 	const TYPE_UNKNOWN_CLASS = 'Standard.Unknown.Class';
@@ -79,13 +80,9 @@ class ErrorConstants {
 	 * @return string[]
 	 */
 	static function getConstants() {
-		$ret = [];
 		$selfReflection = new \ReflectionClass(self::class);
 		$constants = $selfReflection->getConstants();
 		sort($constants);
-		foreach ($constants as $name => $value) {
-			$ret[] = $value;
-		}
-		return $ret;
+		return array_values($constants);
 	}
-}
+}

src/Checks/ParamTypesCheck.php

@@ -42,6 +42,10 @@ public function getCheckNodeTypes() {
 	 */
 	protected function isAllowed(Node\ComplexType|Node\NullableType|Node\Name|Node\Identifier|null $name , ClassLike $inside=null) {
 		$return = true;
+
+		if ($name instanceof Node\NullableType && TypeComparer::isNamedIdentifier($name->type,"null")) {
+			return false;
+		}
 		TypeComparer::forEachAnyEveryType($name, function($name2) use ($inside, &$return) {
 			if($name2===null) {
 				return;
@@ -107,7 +111,7 @@ public function run($fileName, Node $node, ClassLike $inside=null, Scope $scope=
 
 			if ($node->getReturnType()) {
 				$returnType = $node->getReturnType();
-				if (!$this->isAllowed($returnType, $inside)) {
+				if (!TypeComparer::isNamedIdentifier($returnType,"never") && !$this->isAllowed($returnType, $inside)) {
 					$returnType = TypeComparer::typeToString($returnType);
 					$this->emitError($fileName, $node, ErrorConstants::TYPE_UNKNOWN_CLASS, "Reference to an unknown type '$returnType' in return value of $displayName");
 				}

src/Checks/ReturnCheck.php

@@ -63,9 +63,10 @@ public function run($fileName, Node $node, ClassLike $inside = null, Scope $scop
 			$returnType = $insideFunc->getReturnType();
 
 			$returnIsVoid = TypeComparer::isNamedIdentifier($returnType,"void");
-			if ($returnIsVoid) {
+			$returnIsNever = TypeComparer::isNamedIdentifier($returnType,"never");
+			if ($returnIsVoid || $returnIsNever) {
 				if ($node->expr != null) {
-					$this->emitError($fileName, $node, ErrorConstants::TYPE_SIGNATURE_RETURN, "Attempt to return a value from a void function $functionName");
+					$this->emitError($fileName, $node, ErrorConstants::TYPE_SIGNATURE_RETURN, "Attempt to return a value from a ".TypeComparer::typeToString($returnType)." function $functionName");
 					return;
 				}
 			} else if ($returnType && $node->expr == null) {

src/Evaluators/Expression/CallLike.php

@@ -125,8 +125,16 @@ function checkForPropertyCastedCall(Node\Expr\FuncCall $func, ScopeStack $scope)
 		) {
 			$varName = NodePatterns::getVariableOrPropertyName($func->args[0]->value);
 			$type = $this->getCastedCallType(strtolower($func->name));
+
 			if (!is_null($type) && !is_null($varName)) {
-				$this->tagScopeAsType($func, $scope, $varName,$type);
+
+				if ($func->args[0]->value instanceof Node\Expr\NullsafePropertyFetch) {
+					// TODO: confirm all elements are non-null or null-safe, then set all
+					// different lengths of chains as non-null
+					//$list = explode("->", $varName);
+				} else {
+					$this->tagScopeAsType($func, $scope, $varName, $type);
+				}
 			}
 		}
 	}

src/Evaluators/Expression/ConstFetch.php

@@ -28,7 +28,7 @@ function getType(SymbolTable $table, Node\Expr\ConstFetch $expr):?Node\Identifie
 			return TypeComparer::identifierFromName("null");
 		}
 		if (strcasecmp($expr->name, "false") == 0 || strcasecmp($expr->name, "true") == 0) {
-			return TypeComparer::identifierFromName("bool");
+			return TypeComparer::identifierFromName($expr->name);
 		}
 		if (defined($expr->name)) {
 			// Guardrail doesn't declare any global constants.  Any that exist are from the runtime.

src/NodeVisitors/StaticAnalyzer.php

@@ -10,6 +10,7 @@
 use BambooHR\Guardrail\Checks\BreakCheck;
 use BambooHR\Guardrail\Checks\CatchCheck;
 use BambooHR\Guardrail\Checks\ClassConstantCheck;
+use BambooHR\Guardrail\Checks\ClassConstCheck;
 use BambooHR\Guardrail\Checks\ClassMethodStringCheck;
 use BambooHR\Guardrail\Checks\ConditionalAssignmentCheck;
 use BambooHR\Guardrail\Checks\ConstructorCheck;
@@ -149,6 +150,7 @@ function __construct($basePath, $index, OutputInterface $output, $config)
 			new UnsafeSuperGlobalCheck($this->index, $output),
 			new UseStatementCaseCheck($this->index, $output),
 			new ReadOnlyPropertyCheck($this->index, $output),
+			new ClassConstCheck($this->index, $output),
 			//new ClassStoredAsVariableCheck($this->index, $output)
 		];
 

src/TypeComparer.php

@@ -109,6 +109,13 @@ function areSimpleTypesCompatible(Name|Identifier|null $target, Name|Identifier|
 			return true;
 		}
 
+		if (
+			($targetName=="false" || $targetName=="true" || $targetName=="null") &&
+			$valueName!=$targetName
+		) {
+			return false;
+		}
+
 		if (!$strict) {
 			if ($targetName=="mixed" || $valueName=="mixed") {
 				return true;
@@ -126,7 +133,9 @@ function areSimpleTypesCompatible(Name|Identifier|null $target, Name|Identifier|
 	 *
 	 */
 	static function getChainedPropertyFetchName(Node $rootNode):?string {
-		if ($rootNode instanceof Node\Expr\PropertyFetch && $rootNode->name instanceof Identifier) {
+		if (($rootNode instanceof Node\Expr\PropertyFetch  || $rootNode instanceof Node\Expr\NullsafePropertyFetch)
+			&& $rootNode->name instanceof Identifier
+		) {
 			$left = self::getChainedPropertyFetchName($rootNode->var);
 			return $left ? ($left."->".$rootNode->name) : null;
 		} else if ($rootNode instanceof Node\Expr\ArrayDimFetch) {

tests/TestSuiteSetup.php

@@ -1,6 +1,7 @@
 <?php namespace BambooHR\Guardrail\Tests;
 
 use BambooHR\Guardrail\Checks\BaseCheck;
+use BambooHR\Guardrail\Checks\ErrorConstants;
 use BambooHR\Guardrail\Output\OutputInterface;
 use BambooHR\Guardrail\Output\XUnitOutput;
 use BambooHR\Guardrail\Phases\AnalyzingPhase;
@@ -62,6 +63,19 @@ public function analyzeFileToOutput($fileName, $emit, array $additionalConfig =
 		return $output;
 	}
 
+	public function getStringErrorCount($fileData, $additionalConfig=[]):int {
+		$counts = $this->analyzeString($fileData,$additionalConfig)->getCounts();
+		return array_sum($counts);
+	}
+
+	public function analyzeString($fileData, $additionalConfig=[]) {
+		$fileName = "test.php";
+		$emit = ErrorConstants::getConstants();
+		unset( $emit[array_search(ErrorConstants::TYPE_AUTOLOAD_ERROR, $emit)] );
+		$additionalConfig = array_merge(["basePath" => "/"], $additionalConfig);
+		return $this->analyzeStringToOutput($fileName, $fileData, $emit, $additionalConfig);
+	}
+
 	public function analyzeStringToOutput(string $fileName, string $fileData, $emit, array $additionalConfig = []) {
 		if (!str_starts_with($fileData,"<?php")) {
 			$fileData = "<?php\n".$fileData;