@param  PhpParser\Node\Stmt\GroupUse $stmt

@return void
498749
public function visitGroupUse(PhpParser\Node\Stmt\GroupUse $stmt)
    {
        $use_prefix = implode('\\', $stmt->prefix->parts);

        foreach ($stmt->uses as $use) {
            $use_path = $use_prefix . '\\' . implode('\\', $use->name->parts);
            $use_alias = $use->alias ? $use->alias->name : $use->name->getLast();

            switch ($use->type !== PhpParser\Node\Stmt\Use_::TYPE_UNKNOWN ? $use->type : $stmt->type) {
                case PhpParser\Node\Stmt\Use_::TYPE_FUNCTION:
                    $this->aliased_functions[strtolower($use_alias)] = $use_path;
                    break;

                case PhpParser\Node\Stmt\Use_::TYPE_CONSTANT:
                    $this->aliased_constants[$use_alias] = $use_path;
                    break;

                case PhpParser\Node\Stmt\Use_::TYPE_NORMAL:
                    if ($this->getCodebase()->collect_locations) {
                        // register the path
                        $codebase = $this->getCodebase();

                        $codebase->use_referencing_locations[strtolower($use_path)][] =
                            new \Psalm\CodeLocation($this, $use);
                    }

                    $this->aliased_classes[strtolower($use_alias)] = $use_path;
                    $this->aliased_classes_flipped[strtolower($use_path)] = $use_alias;
                    break;
            }
        }
    }
326417
public function writePCM($pcm)
    {
        if ($this->isClosed) {
            return;
        }

        if ($this->isPaused) {
            $this->pcmPauseBuffer[] = $pcm;

            return;
        }

        $this->pcmData .= $pcm;

        $this->emit('pcm', [$pcm]);
    }
1178368
private function processGroups(): void
    {
        // Call the $group by reference because in the case : group of group the size of the array is modified because a new group is added in the group() function.
        foreach ($this->groups as $key => &$group) {
            unset($this->groups[$key]);
            $group();
            //array_pop($this->groups);
        }
    }
1260037
protected function _process( array $stmts )
	{
		$constraint = 'unq_msprost_pid_sid';
		$table = 'mshop_product_stock';
		
		$this->_msg( 'Changing product stock unique constraint', 0 );

		if ( $this->_schema->tableExists( $table ) && $this->_schema->constraintExists( $table, $constraint ) )
		{
			$this->_executeList( $stmts );
			$this->_status( 'changed' );
		} else {
			$this->_status( 'OK' );
		}
	}
1302930
public function addStmt($stmt)
    {
        if (!$this->block) {
            $this->block = new CodeBlock($this->stmts);
            $this->stmts = & $this->block->stmts;
        }
        $stmt = $this->normalizeNode($stmt);
        $this->stmts[] = $stmt;
        return $this;
    }
401637
protected function validateNewExpression(New_ $stmt)
    {
        // if class name is an expression or an anonymous class, give it a pass for now
        if (!$stmt->class instanceof Expr && !$stmt->class instanceof Class_) {
            $this->ensureClassExists($this->getFullyQualifiedName($stmt->class), $stmt);
        }
    }
543572
protected function getScopeType(Stmt $stmt)
    {
        if ($stmt instanceof Class_) {
            return self::CLASS_TYPE;
        } elseif ($stmt instanceof Interface_) {
            return self::INTERFACE_TYPE;
        } elseif ($stmt instanceof Trait_) {
            return self::TRAIT_TYPE;
        }
    }
1331683
public function iterate($stmt, $resultSetMapping, array $hints = [])
    {
        $this->stmt  = $stmt;
        $this->rsm   = $resultSetMapping;
        $this->hints = $hints;

        $evm = $this->em->getEventManager();

        $evm->addEventListener([Events::onClear], $this);

        $this->prepare();

        return new IterableResult($this);
    }
44017
protected function getDocblock(Stmt $stmt, array $uses = [])
    {
        $comments = $stmt->getAttribute('comments');

        if (is_array($comments)) {
            foreach ($comments as $comment) {
                if ($comment instanceof Doc) {
                    return $this->processDocblock($comment->getText(), $uses);
                }
            }
        }

        return null;
    }
550997
protected function _process( array $stmts )
	{
		$this->_msg( 'Renaming service configuration', 0 );

		if( $this->_schema->tableExists( 'mshop_service' )
			&& $this->_schema->columnExists( 'mshop_service', 'config' ) === true
		) {
			$cntRows = 0;

			foreach( $stmts as $stmt )
			{
				$result = $this->_conn->create( $stmt )->execute();
				$cntRows += $result->affectedRows();
				$result->finish();
			}

			if( $cntRows > 0 ) {
				$this->_status( sprintf( 'done (%1$d)', $cntRows ) );
			} else {
				$this->_status( 'OK' );
			}
		}
		else
		{
			$this->_status( 'OK' );
		}
	}
703176
public function setUsage($usage)
    {
        if (is_array($usage) && !empty($usage)) {
            $this->usage = $usage;
        } elseif (is_string($usage) && ($usage != '')) {
            $this->usage = array($usage);
        }
    }
392878
public function removeGroup(int $index): void
    {
        unset($this->groups[$index]);
        $this->groups = array_values($this->groups);
    }
191471
function startGroup(&$group, $required, $error) 
    {
        $this->_currentGroup = $this->_elementToObject($group, $required, $error);
        if(!empty($error)) {
            $name = $this->_currentGroup->name;
            $this->_obj->errors->$name = $error;
        }
    }
1180683
protected function process( array $stmts )
	{
		$this->msg( 'Adding "vatid" column to fe_users tables', 0 ); $this->status( '' );

		foreach( $stmts as $table => $stmt )
		{
			$this->msg( sprintf( 'Checking "%1$s" table', $table ), 1 );

			if( $this->schema->tableExists( $table ) === true
				&& $this->schema->columnExists( $table, 'vatid' ) === false )
			{
				$this->execute( $stmt );
				$this->status( 'added' );
			} else {
				$this->status( 'OK' );
			}
		}
	}
338000
protected function ensureClassOrInterfaceExists($name, $stmt)
    {
        if (!$this->classExists($name) && !$this->interfaceExists($name)) {
            throw $this->createError(\sprintf('Class \'%s\' not found', $name), $stmt);
        }
    }
825628
public function fetchAs($stmt, $type = null)
    {
        $data = [];

        if ((is_null($type) || $type == '') && static::$dataSource) {
            $type = 'class';
            static::$dataSource = false;
        }

        switch (strtolower($type)) {
            case 'group':
                $data = $stmt->fetchAll(\PDO::FETCH_GROUP | \PDO::FETCH_ASSOC);
                break;
            case 'both':
                $data = $stmt->fetchAll(\PDO::FETCH_BOTH);
                break;
            case 'object':
                $data = $stmt->fetchAll(\PDO::FETCH_OBJ);
                break;
            case 'assoc':
                $data = $stmt->fetchAll(\PDO::FETCH_ASSOC);
                break;
            case 'column':
                $data = $stmt->fetchAll(\PDO::FETCH_COLUMN);
                break;
            case 'class':
                $data = $stmt->fetchAll(\PDO::FETCH_CLASS, '\\Cygnite\\Database\\ResultSet');
                break;
            default:
                $data = $stmt->fetchAll(\PDO::FETCH_CLASS, '\\'.self::cyrus()->getModelClassNs());
                break;
        }

        return $data;
    }
1027075
protected function _process( array $stmts )
	{
		$this->_msg( 'Changing list ids to NOT NULL', 0 );
		$this->_status('');
		
		foreach( $stmts as $tablename => $stmt )
		{
			$this->_msg(sprintf('Checking table "%1$s": ', $tablename), 1);
			
			if( $this->_schema->tableExists( $tablename ) === true
				&& $this->_schema->getColumnDetails( $tablename, 'id' )->isNullable() === true )
			{
				$this->_execute( $stmt );
				$this->_status( 'migrated' );
			}
			else
			{
				$this->_status( 'OK' );
			}
		}
	}