Page MenuHomeWickedGov Phorge
Files F4105056

README.md
No OneTemporary
Actions

Size
5 KB
Referenced Files
None
Subscribers
None

README.md
View Options

Layout of src/Phan
==================
Also see https://github.com/phan/phan/wiki/Developer%27s-Guide-To-Phan
Folders
-------
### Analysis
Classes that analyze ASTS. They may do one or more of the following things:
- Emit issues.
- Update Phan's internal state.
- Compute inferences about a given block of code, and update Phan's state for that block (e.g. ConditionVisitor)
- See https://github.com/phan/phan/wiki/Developer%27s-Guide-To-Phan#parsing-and-analysis
### AST
Classes that work with ASTs
- Classes
- ContextNode, which gets information about an AST in it's Context
- Base classes for the different types of visitors
### Daemon
Classes used when Phan is running in the background and receiving requests ("daemon mode"). Also see `LanguageServer/`
- Classes for requests and responses the Phan-specific protocol (i.e. used by `phan_client`)
- Logic for forking off workers to analyze the `CodeBase`, then to receive the analysis results.
### Debug
Utilities for developers working on Phan to debug it.
### Exception
Exception classes used by Phan's implementation.
### Language
Contains data structures for representations of PHP code bases, and methods acting on those data structures.
- E.g. `Context`, `Element`, `FQSEN`, `Internal`, `Scope`, `Type`
- See https://github.com/phan/phan/wiki/Developer%27s-Guide-To-Phan#core-concepts
### LanguageServer
Contains an implementation of the [Language Server Protocol](https://github.com/Microsoft/language-server-protocol), which is a common protocol supported in various IDEs.
Also see `Daemon/`
- Classes that get received and sent over JSON RPC2
- Logic for forking off workers to analyze the `CodeBase`, then to receive the analysis results.
### Library
Contains reusable data structures that aren't specific to analyzing PHP. (Map, Set, Option, Tuple, Hasher, etc.)
### Output
This contains implementation details for printing out Phan issues.
This includes formatters (text, JSON, pylint, etc.) as well as how Phan would colorize issues.
### Parse
This contains implementation details for Phan's initial parse phase.
In the parse phase, all code is parsed in order to build maps from FQSENs to elements.
- See https://github.com/phan/phan/wiki/Developer%27s-Guide-To-Phan#parsing-and-analysis
### Plugin
This contains implementation details for working with the set of plugins loaded by the user (ConfigPluginSet).
`Plugin/Internal` also contains plugins Phan loads automatically (e.g. for improving analysis of `array_map`, `call_user_func`, etc.)
### PluginV3
This contains the current implementation (v3) of the plugin system.
`*Capability.php` contains capabilities that PluginV3 instances can extend.
See https://github.com/phan/phan/wiki/Writing-Plugins-for-Phan for more information on plugin development.
Files
-----
### Analysis.php
This class is the entry point into the static analyzer.
### BlockAnalysisVisitor.php
Analyze blocks of code.
- Uses `\Phan\Analysis\PreOrderAnalysisVisitor` for pre-order analysis of a node (E.g. entering a function to analyze)
- Recursively analyzes child nodes
- Uses `\Phan\Analysis\PostOrderAnalysisVisitor` for post-order analysis of a node (E.g. analyzing a statement with the updated Context and emitting issues)
- If there is more than one possible child context, merges state from them (variable types)
### Bootstrap.php
Sets up error handlers, PHP configuration, and the composer autoloader.
### CLI.php
Contains methods for parsing CLI arguments to Phan,
outputting to the CLI,
as well as helper methods to retrieve files/folders for the analyzed project.
### CodeBase.php
A CodeBase represents the known state of a code base we're analyzing.
It maps FQSENs to the representation of the object for both scanned code and internal PHP elements.
See [Developer's Guide to Phan](https://github.com/phan/phan/wiki/Developer%27s-Guide-To-Phan)
### Config.php
Program configuration. The configuration data is overridden by the analyzed project's `.phan/config.php` as well as CLI options.
### Daemon.php
Implementation of daemon mode. (Daemon for `phan_client`).
Also see `LanguageServer/`
### Debug.php
Mostly utilities for printing representations of AST nodes.
Also see `Debug/`
### ForkPool.php
Contains the ForkPool used for running multiple analysis workers(i.e. `--processes N`)
### IssueInstance.php
Contains an emitted issue with issue details (file, line, format string arguments, etc.)
### Issue.php
Contains the list of built in issue types, as well as common information (Severity, issue names, format strings, remediation difficulty, etc.)
### Memoize.php
A utility trait to memoize (cache) the result of instance methods and static methods.
### Ordering.php
This determines the order in which files will be analyzed.
(Affected by `consistent_hashing_file_order` and `randomize_file_order`.
By default, files are analyzed in the same order as `.phan/config.php`)
### Phan.php
This executes the parse, method/function, then the analysis phases.
This is the entry point of Phan's implementation.
Implementations such as `./phan` or the code climate integration call into this.
### Plugin.php
Deprecated version of plugin system, use PluginV3 instead.
### PluginV3.php
Introduced in Phan 2.0
Plugins must extend this class
(And at least one of the interfaces corresponding to plugin capabilities in the PluginV3 folder)
and return an instance of themselves.
### Prep.php
Part of a separate tool for scanning a code base. Not commonly used.
### Profile.php
For development only: Utility for profiling Phan runs. Used if the `profiler_enabled` config setting is true.
### Util.php

File Metadata

Mime Type
text/plain
Expires
Tue, Aug 18, 18:48 (3 w, 14 h ago)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
76/b1/10e75fdabe6535bba5992b9818c4
Default Alt Text
README.md (5 KB)

Event Timeline