linter: better type inferring

docs/checkers_doc.md

@@ -1252,7 +1252,7 @@ test($arr[1]);
 
 #### Compliant code:
 ```php
-reported not safety call
+reported not safe call call
 ```
 <p><br></p>
 
@@ -1303,7 +1303,7 @@ test(testNullable());
 
 #### Compliant code:
 ```php
-reported not safety call
+reported not safe call call
 ```
 <p><br></p>
 
@@ -1321,7 +1321,7 @@ test(list($a) = [null]);
 
 #### Compliant code:
 ```php
-reported not safety call
+reported not safe call call
 ```
 <p><br></p>
 
@@ -1346,7 +1346,7 @@ echo $user->name;
 
 #### Compliant code:
 ```php
-reported not safety call
+reported not safe call call
 ```
 <p><br></p>
 
@@ -1374,7 +1374,7 @@ test(A::hello());
 
 #### Compliant code:
 ```php
-reported not safety call
+reported not safe call call
 ```
 <p><br></p>
 
@@ -1393,7 +1393,7 @@ function f(A $klass);
 
 #### Compliant code:
 ```php
-reported not safety call with null in variable.
+reported not safe call call with null in variable.
 ```
 <p><br></p>
 
@@ -1413,7 +1413,7 @@ $getUserOrNull()->test();
 
 #### Compliant code:
 ```php
-reported not safety function call
+reported not safe call function call
 ```
 <p><br></p>
 
@@ -1438,7 +1438,7 @@ echo $user->name;
 
 #### Compliant code:
 ```php
-reported not safety call
+reported not safe call call
 ```
 <p><br></p>
 
@@ -1466,7 +1466,7 @@ test(A::hello());
 
 #### Compliant code:
 ```php
-reported not safety static function call
+reported not safe call static function call
 ```
 <p><br></p>
 
@@ -1488,7 +1488,7 @@ echo $user->name;
 
 #### Compliant code:
 ```php
-reported not safety call with null in variable.
+reported not safe call call with null in variable.
 ```
 <p><br></p>
 

src/linter/and_walker.go

@@ -45,6 +45,9 @@ func (a *andWalker) EnterNode(w ir.Node) (res bool) {
 	case *ir.ParenExpr:
 		return true
 
+	case *ir.SimpleVar:
+		a.handleVariableCondition(n)
+
 	case *ir.FunctionCallExpr:
 		// If the absence of a function or method is being
 		// checked, then nothing needs to be done.
@@ -72,6 +75,23 @@ func (a *andWalker) EnterNode(w ir.Node) (res bool) {
 			}
 		}
 
+		switch {
+		case nm.Value == `is_int`:
+			a.handleTypeCheckCondition("int", n.Args)
+		case nm.Value == `is_float`:
+			a.handleTypeCheckCondition("float", n.Args)
+		case nm.Value == `is_string`:
+			a.handleTypeCheckCondition("string", n.Args)
+		case nm.Value == `is_object`:
+			a.handleTypeCheckCondition("object", n.Args)
+		case nm.Value == `is_array`:
+			a.handleTypeCheckCondition("array", n.Args)
+		case nm.Value == `is_null`:
+			a.handleTypeCheckCondition("null", n.Args)
+		case nm.Value == `is_resource`:
+			a.handleTypeCheckCondition("resource", n.Args)
+		}
+
 	case *ir.BooleanAndExpr:
 		a.path.Push(n)
 		n.Left.Walk(a)
@@ -191,6 +211,14 @@ func (a *andWalker) EnterNode(w ir.Node) (res bool) {
 			// TODO: actually this needs to be present inside if body only
 		}
 
+	case *ir.NotIdenticalExpr:
+		a.handleConditionSafety(n.Left, n.Right, false)
+		a.handleConditionSafety(n.Right, n.Left, false)
+
+	case *ir.IdenticalExpr:
+		a.handleConditionSafety(n.Left, n.Right, true)
+		a.handleConditionSafety(n.Right, n.Left, true)
+
 	case *ir.BooleanNotExpr:
 		a.inNot = true
 
@@ -219,6 +247,183 @@ func (a *andWalker) EnterNode(w ir.Node) (res bool) {
 	return res
 }
 
+func (a *andWalker) handleVariableCondition(variable *ir.SimpleVar) {
+	if !a.b.ctx.sc.HaveVar(variable) {
+		return
+	}
+
+	currentType := a.exprType(variable) // nolint:staticcheck
+	if a.inNot {
+		currentType = a.exprTypeInContext(a.trueContext, variable)
+	} else {
+		currentType = a.exprTypeInContext(a.falseContext, variable)
+	}
+
+	var trueType, falseType types.Map
+
+	// First, handle "null": if currentType contains "null", then in the true branch we remove it,
+	// and in the false branch we narrow to "null"
+	if currentType.Contains("null") {
+		trueType = currentType.Clone().Erase("null")
+		falseType = types.NewMap("null")
+	} else {
+		trueType = currentType.Clone()
+		falseType = currentType.Clone()
+	}
+
+	// Next, handle booleans
+	// If currentType contains any boolean-related literal ("bool", "true", "false"),
+	// then we want to narrow them:
+	// - If there are non-boolean parts (e.g. "User") in the union, they are always truthy
+	//   In that case, true branch becomes nonBool ∪ {"true"} and false branch becomes {"false"}
+	// - If only the boolean part is present, then narrow to {"true"} and {"false"} respectively
+	if currentType.Contains("bool") || currentType.Contains("true") || currentType.Contains("false") {
+		nonBool := currentType.Clone().Erase("bool").Erase("true").Erase("false")
+		if nonBool.Len() > 0 {
+			if currentType.Contains("bool") || currentType.Contains("true") {
+				trueType = nonBool.Union(types.NewMap("true"))
+			} else {
+				trueType = nonBool
+			}
+			falseType = types.NewMap("false")
+		} else {
+			trueType = types.NewMap("true")
+			falseType = types.NewMap("false")
+		}
+	}
+
+	// Note: For other types (e.g. int, string, array), our type system doesn't include literal values,
+	// so we don't perform additional narrowing
+
+	// If we are in the "not" context (i.e. if(!$variable)), swap the branches
+	if a.inNot {
+		trueType, falseType = falseType, trueType
+	}
+
+	a.trueContext.sc.ReplaceVar(variable, trueType, "type narrowing for "+variable.Name, meta.VarAlwaysDefined)
+	a.falseContext.sc.ReplaceVar(variable, falseType, "type narrowing for "+variable.Name, meta.VarAlwaysDefined)
+}
+
+func (a *andWalker) handleTypeCheckCondition(expectedType string, args []ir.Node) {
+	for _, arg := range args {
+		argument, ok := arg.(*ir.Argument)
+		if !ok {
+			continue
+		}
+		variable, ok := argument.Expr.(*ir.SimpleVar)
+		if !ok {
+			continue
+		}
+
+		// Traverse the variable to ensure it exists, since this variable
+		// will be added to the context later
+		a.b.handleVariable(variable)
+
+		// Get the current type of the variable from the appropriate context
+		currentType := a.exprType(variable) // nolint:staticcheck
+		if a.inNot {
+			currentType = a.exprTypeInContext(a.trueContext, variable)
+		} else {
+			currentType = a.exprTypeInContext(a.falseContext, variable)
+		}
+
+		var trueType, falseType types.Map
+
+		switch expectedType {
+		case "bool":
+			// For bool: consider possible literal types "bool", "true" and "false"
+			boolMerge := types.MergeMaps(types.NewMap("bool"), types.NewMap("true"), types.NewMap("false"))
+			intersection := currentType.Intersect(boolMerge)
+			if intersection.Empty() {
+				// If there is no explicit bool subtype, then the positive branch becomes simply "bool"
+				trueType = types.NewMap("bool")
+			} else {
+				// Otherwise, keep exactly those literals that were present in the current type
+				trueType = intersection
+			}
+			// Negative branch: remove all bool subtypes
+			falseType = currentType.Clone().Erase("bool").Erase("true").Erase("false")
+		case "object":
+			// For is_object: keep only keys that are not considered primitive
+			keys := currentType.Keys()
+			var objectKeys []string
+			for _, k := range keys {
+				switch k {
+				case "int", "float", "string", "bool", "null", "true", "false", "mixed", "callable", "resource", "void", "iterable", "never":
+					// Skip primitive types
+					continue
+				default:
+					objectKeys = append(objectKeys, k)
+				}
+			}
+			if len(objectKeys) == 0 {
+				trueType = types.NewMap("object")
+			} else {
+				trueType = types.NewEmptyMap(1)
+				for _, k := range objectKeys {
+					trueType = trueType.Union(types.NewMap(k))
+				}
+			}
+			falseType = currentType.Clone()
+			for _, k := range objectKeys {
+				falseType = falseType.Erase(k)
+			}
+		default:
+			// Standard logic for other types
+			trueType = types.NewMap(expectedType)
+			falseType = currentType.Clone().Erase(expectedType)
+		}
+
+		if a.inNot {
+			trueType, falseType = falseType, trueType
+		}
+
+		a.trueContext.sc.ReplaceVar(variable, trueType, "type narrowing for "+expectedType, meta.VarAlwaysDefined)
+		a.falseContext.sc.ReplaceVar(variable, falseType, "type narrowing for "+expectedType, meta.VarAlwaysDefined)
+	}
+}
+
+func (a *andWalker) handleConditionSafety(left ir.Node, right ir.Node, identical bool) {
+	variable, ok := left.(*ir.SimpleVar)
+	if !ok {
+		return
+	}
+
+	constValue, ok := right.(*ir.ConstFetchExpr)
+	if !ok || (constValue.Constant.Value != "false" && constValue.Constant.Value != "null") {
+		return
+	}
+
+	// We need to traverse the variable here to check that
+	// it exists, since this variable will be added to the
+	// context later.
+	a.b.handleVariable(variable)
+
+	currentVar, isGotVar := a.b.ctx.sc.GetVar(variable)
+	if !isGotVar {
+		return
+	}
+
+	var currentType types.Map
+	if a.inNot {
+		currentType = a.exprTypeInContext(a.trueContext, variable)
+	} else {
+		currentType = a.exprTypeInContext(a.falseContext, variable)
+	}
+
+	if constValue.Constant.Value == "false" || constValue.Constant.Value == "null" {
+		clearType := currentType.Erase(constValue.Constant.Value)
+		if identical {
+			a.trueContext.sc.ReplaceVar(variable, currentType.Erase(clearType.String()), "type narrowing", currentVar.Flags)
+			a.falseContext.sc.ReplaceVar(variable, clearType, "type narrowing", currentVar.Flags)
+		} else {
+			a.trueContext.sc.ReplaceVar(variable, clearType, "type narrowing", currentVar.Flags)
+			a.falseContext.sc.ReplaceVar(variable, currentType.Erase(clearType.String()), "type narrowing", currentVar.Flags)
+		}
+		return
+	}
+}
+
 func (a *andWalker) runRules(w ir.Node) {
 	kind := ir.GetNodeKind(w)
 	if a.b.r.anyRset != nil {