public function enterNode(\PHPParser_Node $node)
 {
     // Determine info about the closure's location
     if (!$this->closureNode) {
         if ($node instanceof \PHPParser_Node_Stmt_Namespace) {
             $this->location->namespace = is_array($node->name->parts) ? implode('\\', $node->name->parts) : null;
         }
         if ($node instanceof \PHPParser_Node_Stmt_Trait) {
             $this->location->trait = $this->location->namespace . '\\' . $node->name;
             $this->location->class = null;
         } elseif ($node instanceof \PHPParser_Node_Stmt_Class) {
             $this->location->class = $this->location->namespace . '\\' . $node->name;
             $this->location->trait = null;
         }
     }
     // Locate the node of the closure
     if ($node instanceof \PHPParser_Node_Expr_Closure) {
         if ($node->getAttribute('startLine') == $this->reflection->getStartLine()) {
             if ($this->closureNode) {
                 throw new \RuntimeException('Two closures were declared on the same line of code. Cannot determine ' . 'which closure was the intended target.');
             } else {
                 $this->closureNode = $node;
             }
         }
     }
 }
Beispiel #2
0
 private function processFunction(array $definition, PHPParser_Node $node)
 {
     $message = array(GettextExtractor_Extractor::LINE => $node->getLine());
     foreach ($definition as $type => $position) {
         if (!isset($node->args[$position - 1])) {
             return;
         }
         $arg = $node->args[$position - 1]->value;
         if ($arg instanceof PHPParser_Node_Scalar_String) {
             $message[$type] = $arg->value;
         } elseif ($arg instanceof PHPParser_Node_Expr_Array) {
             foreach ($arg->items as $item) {
                 if ($item->value instanceof PHPParser_Node_Scalar_String) {
                     $message[$type][] = $item->value->value;
                 }
             }
             if (count($message) === 1) {
                 // line only
                 return;
             }
         } else {
             return;
         }
     }
     if (is_array($message[GettextExtractor_Extractor::SINGULAR])) {
         foreach ($message[GettextExtractor_Extractor::SINGULAR] as $value) {
             $tmp = $message;
             $tmp[GettextExtractor_Extractor::SINGULAR] = $value;
             $this->data[] = $tmp;
         }
     } else {
         $this->data[] = $message;
     }
 }
 /**
  * Dumps a node or array.
  *
  * @param array|PHPParser_Node $node Node or array to dump
  *
  * @return string Dumped value
  */
 public function dump($node)
 {
     if ($node instanceof PHPParser_Node) {
         $r = $node->getType() . '(';
     } elseif (is_array($node)) {
         $r = 'array(';
     } else {
         throw new InvalidArgumentException('Can only dump nodes and arrays.');
     }
     foreach ($node as $key => $value) {
         $r .= "\n" . '    ' . $key . ': ';
         if (null === $value) {
             $r .= 'null';
         } elseif (false === $value) {
             $r .= 'false';
         } elseif (true === $value) {
             $r .= 'true';
         } elseif (is_scalar($value)) {
             $r .= $value;
         } else {
             $r .= str_replace("\n", "\n" . '    ', $this->dump($value));
         }
     }
     return $r . "\n" . ')';
 }
 /**
  * {@inheritdoc}
  */
 public function leaveNode(PHPParser_Node $node)
 {
     if (!isset($this->metaData[$node->getType()])) {
         return;
     }
     $this->checkSize($node);
 }
Beispiel #5
0
 /**
  * Swap out __DIR__ and __FILE__ constants, because the default ones when
  * calling eval() don't make sense.
  *
  * @param Node $node
  *
  * @return null|FunctionCall|StringNode
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof DirConstant) {
         return new FunctionCall(new Name('getcwd'), array(), $node->getAttributes());
     } elseif ($node instanceof FileConstant) {
         return new StringNode('', $node->getAttributes());
     }
 }
 public function leaveNode(\PHPParser_Node $node)
 {
     if (isset($node->stmts)) {
         $node->stmts = new BlockNode($node->stmts, $node->getLine());
     }
     if ($node instanceof \PHPParser_Node_Stmt_Namespace) {
         $node->setAttribute('imports', $this->imports);
     }
 }
Beispiel #7
0
 /**
  * Validate that namespaced constant references will succeed.
  *
  * Note that this does not (yet) detect constants defined in the current code
  * snippet. It won't happen very often, so we'll punt for now.
  *
  * @throws FatalErrorException if a constant reference is not defined.
  *
  * @param Node $node
  */
 public function leaveNode(Node $node)
 {
     if ($node instanceof ConstantFetch && count($node->name->parts) > 1) {
         $name = $this->getFullyQualifiedName($node->name);
         if (!defined($name)) {
             throw new FatalErrorException(sprintf('Undefined constant %s', $name), 0, 1, null, $node->getLine());
         }
     }
 }
 /**
  * Normalizes a node: Converts builder objects to nodes.
  *
  * @param PHPParser_Node|PHPParser_Builder $node The node to normalize
  *
  * @return PHPParser_Node The normalized node
  */
 protected function normalizeNode($node)
 {
     if ($node instanceof PHPParser_Builder) {
         return $node->getNode();
     } elseif ($node instanceof PHPParser_Node) {
         return $node;
     }
     throw new LogicException('Expected node or builder object');
 }
 /**
  * {@inheritDoc}
  */
 public function leaveNode(\PHPParser_Node $node)
 {
     if ($node->getType() === 'Stmt_Class') {
         if ($this->newInterface) {
             $this->newContent[] = $this->buildNewInterface();
         }
         $this->newInterface = false;
     }
     parent::leaveNode($node);
 }
 /**
  * @param \PHPParser_Node $node
  * @return PHPParser_Node|void
  */
 public function leaveNode(PHPParser_Node $node)
 {
     if (NULL !== $node->__get('class')) {
         $oldClassName = Tx_PhpParser_Parser_Utility_NodeConverter::getValueFromNode($node->__get('class'));
         if (strpos($oldClassName, $this->oldClassPrefix) !== FALSE) {
             $newClassName = str_replace($this->oldClassPrefix, $this->newClassPrefix, $oldClassName);
             $node->setClass(Tx_PhpParser_Parser_NodeFactory::buildNodeFromName($newClassName));
             return $node;
         }
     }
 }
Beispiel #11
0
 public function getNodeCode(\PHPParser_Node $node)
 {
     $startPos = $node->getAttribute('startOffset');
     $endPos = $node->getAttribute('endOffset');
     if ($startPos === null || $endPos === null) {
         return '';
         // just to be sure
     }
     $startOffset = $this->tokenToStartOffset[$startPos];
     $endOffset = $this->tokenToEndOffset[$endPos];
     return substr($this->code, $startOffset, $endOffset - $startOffset);
 }
Beispiel #12
0
 public function leaveNode(\PHPParser_Node $node)
 {
     if ($node instanceof \PHPParser_Node_Stmt_Trait) {
         // Leave traits implemented as classes.
         // It prevents that files that require/use them break.
         $klass = new \PhpParser\Node\Stmt\Class_($node->name, ['stmts' => $node->stmts], $node->getAttributes());
         return $klass;
     }
     if ($node instanceof \PHPParser_Node_Stmt_TraitUse) {
         return false;
     }
 }
Beispiel #13
0
 protected function compileNode(\PHPParser_Node $node, Zval\Ptr $returnContext = null)
 {
     $nodeType = $node->getType();
     if (isset($this->operators[$nodeType])) {
         call_user_func_array(array($this, 'compile' . $this->operators[$nodeType][0]), array_merge(array($node, $returnContext), array_slice($this->operators[$nodeType], 1)));
         return;
     }
     $methodName = 'compile_' . $nodeType;
     if (!method_exists($this, $methodName)) {
         var_dump($node);
         throw new CompileException($nodeType . ' not supported yet', $node->line);
     }
     call_user_func(array($this, $methodName), $node, $returnContext);
 }
 /**
  * {@inheritdoc}
  */
 public function leaveNode(PHPParser_Node $node)
 {
     return;
     switch ($node->getType()) {
         case 'Stmt_ClassMethod':
         case 'Expr_Closure':
         case 'Stmt_Function':
         case 'Stmt_If':
         case 'Stmt_Do':
         case 'Stmt_While':
         case 'Stmt_For':
         case 'Stmt_Foreach':
             break;
     }
 }
 /**
  * @depends testConstruct
  */
 public function testChange(PHPParser_Node $node)
 {
     // change of line
     $node->setLine(15);
     $this->assertEquals(15, $node->getLine());
     // direct modification
     $node->subNode = 'newValue';
     $this->assertEquals('newValue', $node->subNode);
     // indirect modification
     $subNode =& $node->subNode;
     $subNode = 'newNewValue';
     $this->assertEquals('newNewValue', $node->subNode);
     // removal
     unset($node->subNode);
     $this->assertFalse(isset($node->subNode));
 }
 public function enterNode(PHPParser_Node $node)
 {
     if ($node instanceof PHPParser_Node_Stmt_Namespace) {
         $this->namespace = $node->name;
         $this->aliases = array();
     } elseif ($node instanceof PHPParser_Node_Stmt_UseUse) {
         if (isset($this->aliases[$node->alias])) {
             throw new PHPParser_Error(sprintf('Cannot use "%s" as "%s" because the name is already in use', $node->name, $node->alias), $node->getLine());
         }
         $this->aliases[$node->alias] = $node->name;
     } elseif ($node instanceof PHPParser_Node_Stmt_Class) {
         if (null !== $node->extends) {
             $node->extends = $this->resolveClassName($node->extends);
         }
         foreach ($node->implements as &$interface) {
             $interface = $this->resolveClassName($interface);
         }
         $this->addNamespacedName($node);
     } elseif ($node instanceof PHPParser_Node_Stmt_Interface) {
         foreach ($node->extends as &$interface) {
             $interface = $this->resolveClassName($interface);
         }
         $this->addNamespacedName($node);
     } elseif ($node instanceof PHPParser_Node_Stmt_Trait) {
         $this->addNamespacedName($node);
     } elseif ($node instanceof PHPParser_Node_Stmt_Function) {
         $this->addNamespacedName($node);
     } elseif ($node instanceof PHPParser_Node_Stmt_Const) {
         foreach ($node->consts as $const) {
             $this->addNamespacedName($const);
         }
     } elseif ($node instanceof PHPParser_Node_Expr_StaticCall || $node instanceof PHPParser_Node_Expr_StaticPropertyFetch || $node instanceof PHPParser_Node_Expr_ClassConstFetch || $node instanceof PHPParser_Node_Expr_New || $node instanceof PHPParser_Node_Expr_Instanceof) {
         if ($node->class instanceof PHPParser_Node_Name) {
             $node->class = $this->resolveClassName($node->class);
         }
     } elseif ($node instanceof PHPParser_Node_Expr_FuncCall || $node instanceof PHPParser_Node_Expr_ConstFetch) {
         if ($node->name instanceof PHPParser_Node_Name) {
             $node->name = $this->resolveOtherName($node->name);
         }
     } elseif ($node instanceof PHPParser_Node_Stmt_TraitUse) {
         foreach ($node->traits as &$trait) {
             $trait = $this->resolveClassName($trait);
         }
     } elseif ($node instanceof PHPParser_Node_Param && $node->type instanceof PHPParser_Node_Name) {
         $node->type = $this->resolveClassName($node->type);
     }
 }
 /**
  * {@inheritDoc}
  */
 public function leaveNode(\PHPParser_Node $node)
 {
     switch ($node->getType()) {
         case 'Stmt_Class':
         case 'Stmt_Interface':
         case 'Stmt_Trait':
             $this->currentClass = false;
             break;
         case 'Stmt_ClassMethod':
             $this->currentMethod = false;
             break;
         case 'PhpFile':
             if ($this->currentPhpFile->isModified()) {
                 return $this->currentPhpFile;
             }
             break;
     }
 }
Beispiel #18
0
 public function leaveNode(PHPParser_Node $node)
 {
     if ($node instanceof PHPParser_Node_Expr_Array) {
         return new PHPParser_Node_Expr_AssignListInner($node->getSubNodes());
     } elseif ($node instanceof PHPParser_Node_Expr_Variable || $node instanceof PHPParser_Node_Expr_ConstFetch) {
         return null;
     } elseif ($node instanceof PHPParser_Node_Name && $node->parts[0] === "null") {
         return new PHPParser_Node_Expr_Pass(array());
     } elseif ($node instanceof PHPParser_Node_Expr_ArrayItem) {
         if ($node->key !== null) {
             throw new PHPParser_Error(self::keyFound, $node->getLine());
         }
         if ($node->byRef !== false) {
             throw new PHPParser_Error(self::byRefFound, $node->getLine());
         }
     } else {
         return $node;
     }
 }
 /**
  * Pretty prints a node.
  *
  * @param PHPParser_Node $node Node to be pretty printed
  *
  * @return string Pretty printed node
  */
 protected function p(PHPParser_Node $node)
 {
     $type = $node->getType();
     if (isset($this->precedanceMap[$type])) {
         $precedence = $this->precedanceMap[$type];
         if ($precedence >= $this->precedenceStack[$this->precedenceStackPos]) {
             $this->precedenceStack[++$this->precedenceStackPos] = $precedence;
             $return = '(' . $this->{'p' . $type}($node) . ')';
             --$this->precedenceStackPos;
         } else {
             $this->precedenceStack[++$this->precedenceStackPos] = $precedence;
             $return = $this->{'p' . $type}($node);
             --$this->precedenceStackPos;
         }
         return $return;
     } else {
         return $this->{'p' . $type}($node);
     }
 }
Beispiel #20
0
 public function enterNode(\PHPParser_Node $node)
 {
     if (!$node instanceof \PHPParser_Node_Scalar_String) {
         return;
     }
     $id = $node->value;
     if (preg_match('/(\\.\\.|\\.\\.\\.)/', $id)) {
         return;
     }
     if (preg_match('/^http/', $id)) {
         return;
     }
     if (preg_match('/.*\\./', $id)) {
         $domain = 'messages';
         $message = new Message($id, $domain);
         $message->addSource(new FileSource((string) $this->file, $node->getLine()));
         $this->catalogue->add($message);
     }
 }
 /**
  * {@inheritdoc}
  */
 public function leaveNode(\PHPParser_Node $node)
 {
     switch ($node->getType()) {
         case 'Stmt_ClassMethod':
             $this->currentMethodRelevant = false;
             break;
         case 'Stmt_Class':
             // generate
             foreach ($this->factoryMethodStack as $name => $calling) {
                 $factory = new \PHPParser_Node_Stmt_ClassMethod($name);
                 $factory->type = \PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED;
                 $factory->params = $this->getProcessedArgument($calling->args);
                 $class = $calling->getAttribute('classShortcut');
                 $factory->stmts = array(new \PHPParser_Node_Stmt_Return(new \PHPParser_Node_Expr_New(new \PHPParser_Node_Name($class), $factory->params)));
                 $this->currentClassStmts[] = $factory;
             }
             break;
     }
     return parent::leaveNode($node);
 }
 public function leaveNode(\PHPParser_Node $node)
 {
     switch ($node->getType()) {
         case 'Scalar_MagicConst_Line':
             return new NumberNode($node->getAttribute('startLine'));
         case 'Scalar_MagicConst_File':
             return new StringNode($this->location->file);
         case 'Scalar_MagicConst_Dir':
             return new StringNode($this->location->directory);
         case 'Scalar_MagicConst_Function':
             return new StringNode($this->location->function);
         case 'Scalar_MagicConst_Namespace':
             return new StringNode($this->location->namespace);
         case 'Scalar_MagicConst_Class':
             return new StringNode($this->location->class);
         case 'Scalar_MagicConst_Method':
             return new StringNode($this->location->method);
         case 'Scalar_MagicConst_Trait':
             return new StringNode($this->location->trait);
     }
 }
 /**
  * Returns the type of the given node in the flow scope.
  *
  * If the node cannot be matched to a slot, or simply is not capable of being
  * refined, then this method returns null.
  *
  * @return PhpType|null
  */
 public function getTypeIfRefinable(\PHPParser_Node $node, LinkedFlowScope $scope)
 {
     switch (true) {
         case $node instanceof \PHPParser_Node_Expr_ArrayDimFetch:
             $varType = $this->getTypeIfRefinable($node->var, $scope);
             if ($varType && $varType->isArrayType()) {
                 $dim = \Scrutinizer\PhpAnalyzer\PhpParser\NodeUtil::getValue($node->dim);
                 if ($dim->isEmpty()) {
                     return null;
                 }
                 return $dim->flatMap([$varType, 'getItemType'])->getOrCall([$varType, 'getElementType']);
             }
             return null;
             // Handle the common pattern of assigning the result of an expression
             // inside of a condition, e.g. ``if (null !== $obj = $this->findObj())``.
         // Handle the common pattern of assigning the result of an expression
         // inside of a condition, e.g. ``if (null !== $obj = $this->findObj())``.
         case $node instanceof \PHPParser_Node_Expr_Assign:
         case $node instanceof \PHPParser_Node_Expr_AssignRef:
             if (TypeInference::hasQualifiedName($node->var) && null !== ($qualifiedName = TypeInference::getQualifiedName($node->var)) && null !== ($nameVar = $scope->getSlot($node->var->name))) {
                 if (null !== ($nameType = $nameVar->getType())) {
                     return $nameType;
                 }
                 return $node->var->getAttribute('type');
             }
             return null;
         case $node instanceof \PHPParser_Node_Expr_Variable:
             if (is_string($node->name)) {
                 $nameVar = $scope->getSlot($node->name);
                 if (null !== $nameVar) {
                     if (null !== $nameVar->getType()) {
                         return $nameVar->getType();
                     }
                     return $node->getAttribute('type');
                 }
             }
             return null;
         case $node instanceof \PHPParser_Node_Expr_StaticPropertyFetch:
         case $node instanceof \PHPParser_Node_Expr_PropertyFetch:
             if (null === ($qualifiedName = TypeInference::getQualifiedName($node))) {
                 return null;
             }
             $propVar = $scope->getSlot($qualifiedName);
             if (null !== $propVar && null !== $propVar->getType()) {
                 return $propVar->getType();
             }
             if (null !== ($type = $node->getAttribute('type'))) {
                 return $type;
             }
             return null;
     }
     return null;
 }
Beispiel #24
0
 /**
  * Validate that function calls will succeed.
  *
  * @throws FatalErrorException if a function is redefined.
  * @throws FatalErrorException if the function name is a string (not an expression) and is not defined.
  *
  * @param Node $node
  */
 public function leaveNode(Node $node)
 {
     if ($node instanceof FunctionStatement) {
         $name = $this->getFullyQualifiedName($node->name);
         if (function_exists($name) || isset($this->currentScope[strtolower($name)])) {
             throw new FatalErrorException(sprintf('Cannot redeclare %s()', $name), 0, 1, null, $node->getLine());
         }
         $this->currentScope[strtolower($name)] = true;
     } elseif ($node instanceof FunctionCall) {
         // if function name is an expression, give it a pass for now.
         $name = $node->name;
         if (!$name instanceof Expression) {
             $shortName = implode('\\', $name->parts);
             $fullName = $this->getFullyQualifiedName($name);
             if (!isset($this->currentScope[strtolower($fullName)]) && !function_exists($shortName) && !function_exists($fullName)) {
                 $message = sprintf('Call to undefined function %s()', $name);
                 throw new FatalErrorException($message, 0, 1, null, $node->getLine());
             }
         }
     }
 }
 public function setInput($code, \PHPParser_Node $ast = null)
 {
     $this->astStream->setAst($ast ?: PhpParser\ParseUtils::parse($code));
     $this->tokenStream->setCode($code);
     $lastNode = null;
     while ($this->moveNext()) {
         if ($lastNode !== $this->node) {
             $this->node->setAttribute('start_token', $this->token);
             if (null !== $lastNode) {
                 $lastNode->setAttribute('end_token', $this->token->getPreviousToken()->get());
             }
         }
         $lastNode = $this->node;
     }
     $this->reset();
 }
 private function getDocCommentForNode(\PHPParser_Node $node)
 {
     // check if there is a doc comment for the ID argument
     // ->trans(/** @Desc("FOO") */ 'my.id')
     if (null !== ($comment = $node->args[0]->getDocComment())) {
         return $comment->getText();
     }
     // this may be placed somewhere up in the hierarchy,
     // -> /** @Desc("FOO") */ trans('my.id')
     // /** @Desc("FOO") */ ->trans('my.id')
     // /** @Desc("FOO") */ $translator->trans('my.id')
     if (null !== ($comment = $node->getDocComment())) {
         return $comment->getText();
     } elseif (null !== $this->previousNode && $this->previousNode->getDocComment() !== null) {
         $comment = $this->previousNode->getDocComment();
         return is_object($comment) ? $comment->getText() : $comment;
     }
     return null;
 }
 protected function addNamespacedName(PHPParser_Node $node)
 {
     if (null !== $this->namespace) {
         $node->namespacedName = clone $this->namespace;
         $node->namespacedName->append($node->name);
     } else {
         $node->namespacedName = new PHPParser_Node_Name($node->name, $node->getAttributes());
     }
 }
 private function attachLiteralTypes(\PHPParser_Node $node, \PHPParser_Node $parent = null)
 {
     switch (true) {
         case $node instanceof \PHPParser_Node_Name_FullyQualified:
             $node->setAttribute('type', $this->typeRegistry->getClassOrCreate(implode("\\", $node->parts)));
             break;
         case $node instanceof \PHPParser_Node_Name:
             if ($parent instanceof \PHPParser_Node_Expr_New || $parent instanceof \PHPParser_Node_Expr_StaticPropertyFetch || $parent instanceof \PHPParser_Node_Expr_StaticCall || $parent instanceof \PHPParser_Node_Expr_Instanceof || $parent instanceof \PHPParser_Node_Stmt_Catch) {
                 $name = implode("\\", $node->parts);
                 $lowerName = strtolower($name);
                 if ('static' === $name) {
                     $node->setAttribute('type', $this->typeRegistry->getThisType($this->scope->getTypeOfThis()));
                 } else {
                     if ('self' === $name) {
                         $node->setAttribute('type', $this->scope->getTypeOfThis());
                     } else {
                         if ('parent' === $name) {
                             $thisType = $this->scope->getTypeOfThis()->toMaybeObjectType();
                             if (null === $thisType || !$thisType->isClass() || null === $thisType->getSuperClassType()) {
                                 $node->setAttribute('type', $this->typeRegistry->getNativeType('unknown'));
                             } else {
                                 $node->setAttribute('type', $thisType->getSuperClassType());
                             }
                         } else {
                             $node->setAttribute('type', $this->typeRegistry->getClassOrCreate($name));
                         }
                     }
                 }
             }
             break;
         case $node instanceof \PHPParser_Node_Expr_Array:
         case $node instanceof \PHPParser_Node_Expr_Cast_Array:
             // We only do attach the generic array type on the first build.
             // For subsequent builds, other passes likely have already made
             // the array type more specific.
             if (null === $node->getAttribute('type')) {
                 $node->setAttribute('type', $this->typeRegistry->getNativeType('array'));
             }
             break;
         case $node instanceof \PHPParser_Node_Expr_UnaryMinus:
         case $node instanceof \PHPParser_Node_Expr_UnaryPlus:
         case $node instanceof \PHPParser_Node_Scalar_LNumber:
         case $node instanceof \PHPParser_Node_Scalar_LineConst:
             $node->setAttribute('type', $this->typeRegistry->getNativeType('integer'));
             break;
         case $node instanceof \PHPParser_Node_Scalar_DNumber:
             $node->setAttribute('type', $this->typeRegistry->getNativeType('double'));
             break;
         case $node instanceof \PHPParser_Node_Scalar_String:
         case $node instanceof \PHPParser_Node_Scalar_FileConst:
         case $node instanceof \PHPParser_Node_Scalar_DirConst:
             $node->setAttribute('type', $this->typeRegistry->getNativeType('string'));
             break;
         case $node instanceof \PHPParser_Node_Expr_ClassConstFetch:
             if ($node->class instanceof \PHPParser_Node_Name && in_array($node->class->parts[0], array('self', 'static')) && null !== ($thisType = $this->scope->getTypeOfThis()) && null !== ($objType = $thisType->toMaybeObjectType()) && ($objType->isClass() || $objType->isInterface()) && $objType->hasConstant($node->name)) {
                 $node->setAttribute('type', $objType->getConstant($node->name)->getPhpType());
             }
             break;
         case $node instanceof \PHPParser_Node_Expr_ConstFetch:
             $nameParts = $node->name->parts;
             if (1 === count($nameParts)) {
                 $name = strtolower($nameParts[0]);
                 if ('true' === $name) {
                     $node->setAttribute('type', $this->typeRegistry->getNativeType('boolean'));
                 } else {
                     if ('false' === $name) {
                         $node->setAttribute('type', $this->typeRegistry->getNativeType('false'));
                     } else {
                         if ('null' === $name) {
                             $node->setAttribute('type', $this->typeRegistry->getNativeType('null'));
                         }
                     }
                 }
             }
             break;
     }
 }
 /**
  * Returns the class a method was called on.
  *
  * @param \PHPParser_Node $node
  *
  * @return null|PhpType
  */
 public function getCalledClassByNode(\PHPParser_Node $node)
 {
     switch (true) {
         case $node instanceof \PHPParser_Node_Expr_MethodCall:
             if (null === ($objType = $node->var->getAttribute('type'))) {
                 return null;
             }
             return $objType->restrictByNotNull()->toMaybeObjectType();
         case $node instanceof \PHPParser_Node_Expr_StaticCall:
             if (null === ($objType = $node->class->getAttribute('type'))) {
                 return null;
             }
             return $objType->restrictByNotNull()->toMaybeObjectType();
         case $node instanceof \PHPParser_Node_Expr_New:
             if (null === ($objType = $node->getAttribute('type'))) {
                 return null;
             }
             return $objType->restrictByNotNull()->toMaybeObjectType();
         default:
             throw new \InvalidArgumentException('The node class "' . get_class($node) . '" is not resolvable to a function/method.');
     }
 }
 public function enterNode(\PHPParser_Node $node)
 {
     if ($node instanceof \PHPParser_Node_Stmt_Namespace) {
         $this->namespace = implode('\\', $node->name->parts);
         return;
     }
     if ($node instanceof \PHPParser_Node_Stmt_Class) {
         $name = '' === $this->namespace ? $node->name : $this->namespace . '\\' . $node->name;
         if (!class_exists($name)) {
             return;
         }
         $ref = new \ReflectionClass($name);
         if (!$ref->isSubclassOf('Symfony\\Component\\Security\\Core\\Exception\\AuthenticationException') && $ref->name !== 'Symfony\\Component\\Security\\Core\\Exception\\AuthenticationException') {
             return;
         }
         if (!$ref->hasMethod('getMessageKey')) {
             return;
         }
         $this->inAuthException = true;
         return;
     }
     if (!$this->inAuthException) {
         return;
     }
     if ($node instanceof \PHPParser_Node_Stmt_ClassMethod) {
         if ('getmessagekey' === strtolower($node->name)) {
             $this->inGetMessageKey = true;
         }
         return;
     }
     if (!$this->inGetMessageKey) {
         return;
     }
     if (!$node instanceof \PHPParser_Node_Stmt_Return) {
         return;
     }
     $ignore = false;
     $desc = $meaning = null;
     if ($docComment = $node->getDocComment()) {
         foreach ($this->docParser->parse($docComment->getText(), 'file ' . $this->file . ' near line ' . $node->getLine()) as $annot) {
             if ($annot instanceof Ignore) {
                 $ignore = true;
             } else {
                 if ($annot instanceof Desc) {
                     $desc = $annot->text;
                 } else {
                     if ($annot instanceof Meaning) {
                         $meaning = $annot->text;
                     }
                 }
             }
         }
     }
     if (!$node->expr instanceof \PHPParser_Node_Scalar_String) {
         if ($ignore) {
             return;
         }
         $message = sprintf('Could not extract id from return value, expected scalar string but got %s (in %s on line %d).', get_class($node->expr), $this->file, $node->expr->getLine());
         if ($this->logger) {
             $this->logger->err($message);
             return;
         }
         throw new RuntimeException($message);
     }
     $message = Message::create($node->expr->value, $this->domain)->setDesc($desc)->setMeaning($meaning)->addSource(new FileSource((string) $this->file, $node->expr->getLine()));
     $this->catalogue->add($message);
 }