Implement Analysis\TolerantExpressionAnalyser and tests

TimeToogo · Apr 7, 2015 · fcf5b32 · fcf5b32
1 parent c66ed83
commit fcf5b32
Show file tree

Hide file tree

Showing 5 changed files with 100 additions and 3 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,7 @@ dev-master
 ==========
  - Refactor `Analysis\PhpTypeSystem::getTypeFromValue` method logic into new static method `Analysis\TypeId::fromValue`
  - Fix bug when attempting to parse function with a magic scope parameter type hint (eg `function (self $param) { ... }`.
+ - Implement `Analysis\TolerantExpressionAnalyser` which will convert analysis exceptions into the *mixed* type.
 
 3.1.0 (29/3/15)
 ===============

diff --git a/Source/Analysis/ExpressionAnalyser.php b/Source/Analysis/ExpressionAnalyser.php
@@ -136,15 +136,26 @@ public function visitCast(O\CastExpression $expression)
 
     public function visitConstant(O\ConstantExpression $expression)
     {
+        $this->verifyConstantDefined($expression->getName());
+
         $this->analysis[$expression] = $this->typeSystem->getTypeFromValue($expression->evaluate($this->analysisContext->getEvaluationContext()));
     }
 
     public function visitClassConstant(O\ClassConstantExpression $expression)
     {
         $this->validateStaticClassName($expression->getClass(), 'class constant');
+        $this->verifyConstantDefined($expression->getClass()->getValue() . '::' . $expression->getName());
+
         $this->analysis[$expression] = $this->typeSystem->getTypeFromValue($expression->evaluate($this->analysisContext->getEvaluationContext()));
     }
 
+    private function verifyConstantDefined($constantName)
+    {
+        if (!defined($constantName)) {
+            throw new TypeException('Cannot get type from constant %s: constant is not defined', $constantName);
+        }
+    }
+
     public function visitEmpty(O\EmptyExpression $expression)
     {
         $this->walk($expression->getValue());

diff --git a/Source/Analysis/TolerantExpressionAnalyser.php b/Source/Analysis/TolerantExpressionAnalyser.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Pinq\Analysis;
+
+use Pinq\Expressions as O;
+
+/**
+ * Implementation of the expression type analyser that will
+ * convert exceptions from not being able to be statically analysed
+ * into the mixed type.
+ *
+ * @author Elliot Levin <elliotlevin@hotmail.com>
+ */
+class TolerantExpressionAnalyser extends ExpressionAnalyser
+{
+    protected function doWalk(O\Expression $expression)
+    {
+        $caught = false;
+        try {
+            return parent::doWalk($expression);
+        } catch (TypeException $exception) {
+            $caught = true;
+        } catch (\ReflectionException $exception) {
+            $caught = true;
+        }
+
+        if($caught) {
+            $this->analysis[$expression] = $this->typeSystem->getNativeType(INativeType::TYPE_MIXED);
+            return $expression;
+        }
+    }
+}
diff --git a/Tests/Integration/Analysis/ExpressionAnalysisTestCase.php b/Tests/Integration/Analysis/ExpressionAnalysisTestCase.php
@@ -105,12 +105,16 @@ protected function assertReturnsObjectType(callable $expression, $objectType, ar
 
     protected function assertAnalysisFails(callable $expression, array $variableTypeMap = [], $message = '')
     {
+        $failed = false;
         try {
             $this->getAnalysis($expression, $variableTypeMap);
-            $this->fail(
-                    'Expecting analysis to fail with exception of type \\Pinq\\Analysis\\TypeException: no exception was thrown' . $message);
-        } catch (\Exception $exception) {
+            $failed = true;
+        } catch (\Exception $exception) {}
 
+        if($failed) {
+            $this->fail(
+                    'Expecting analysis to fail with exception of type \\Pinq\\Analysis\\TypeException: no exception was thrown' . $message
+            );
         }
     }
 

diff --git a/Tests/Integration/Analysis/TolerantExpressionAnalysisTest.php b/Tests/Integration/Analysis/TolerantExpressionAnalysisTest.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Pinq\Tests\Integration\Analysis;
+
+use Pinq\Analysis\INativeType;
+use Pinq\Analysis\TolerantExpressionAnalyser;
+use Pinq\Expressions as O;
+
+/**
+ * @author Elliot Levin <elliotlevin@hotmail.com>
+ */
+class WeakExpressionAnalysisTest extends ExpressionAnalysisTestCase
+{
+    protected function setUpExpressionAnalyser()
+    {
+        return new TolerantExpressionAnalyser($this->typeSystem);
+    }
+
+    public function testThatUnknownVariableReturnsMixed()
+    {
+        $this->assertReturnsNativeType(function () { $var; }, INativeType::TYPE_MIXED);
+    }
+
+    public function testThatDynamicExpressionsReturnsMixed()
+    {
+        $this->assertReturnsNativeType(function () { $class::$field; }, INativeType::TYPE_MIXED);
+        $this->assertReturnsNativeType(function () { $class::method(); }, INativeType::TYPE_MIXED);
+        $this->assertReturnsNativeType(function () { Foo::$method(); }, INativeType::TYPE_MIXED);
+        $this->assertReturnsNativeType(function () { Foo::$$field; }, INativeType::TYPE_MIXED);
+        $this->assertReturnsNativeType(function () { $this->$foo; }, INativeType::TYPE_MIXED);
+        $this->assertReturnsNativeType(function () { $this->field; }, INativeType::TYPE_MIXED);
+        $this->assertReturnsNativeType(function () { $this->field[434]->{__NON_CONSTANT}->abc()[self::NON_CONSTANT]; }, INativeType::TYPE_MIXED);
+    }
+
+    public function testThatAllUnknownExpressionsAreMixedInTheTypeAnalysis()
+    {
+        $analysis = $this->getAnalysis(function () {
+            $this->field[434]->abc();
+        });
+
+        /** @var O\VariableExpression $variable */
+        $variable = $analysis
+            ->getExpression()
+            ->getValue()
+            ->getValue();
+
+        $this->assertSame(INativeType::TYPE_MIXED, $analysis->getReturnTypeOf($variable)->getIdentifier());
+    }
+}