0.7.0

Added

• @psalm-return, @psalm-param, and @psalm-var tag support. Psalm-prefixed docblock tags are now recognized alongside their PHPStan equivalents for return types, parameter types, variable types, conditional return types, template parameter bindings, and semantic token highlighting.
• Refactoring code actions. Extract function, extract method, extract variable, extract constant, inline variable, promote constructor parameter, generate constructor (traditional and promoted), generate getter/setter, and generate property hooks (PHP 8.4+). Deferred computation ensures the lightbulb menu appears instantly; edit generation only runs when the user picks an action.
• PHPStan quickfixes. Automated fixes for a wide range of PHPStan diagnostics: update or remove mismatched @return/@param/@var tags, remove unused return type union members, fix unsafe new static() (add @phpstan-consistent-constructor, final class, or final constructor), add or remove #[Override], add #[\ReturnTypeWillChange], fix void return mismatches, add inferred iterable return types, remove unreachable statements, remove always-true assert() calls, fix overriding member visibility, fix vendor-prefixed class names, and simplify ternary expressions to ?? or ?->. All quickfixes eagerly clear their diagnostic on apply.
• fix CLI subcommand. phpantom_lsp fix applies automated code fixes across a project. Specify rules with --rule (multiple allowed) or omit to run all preferred fixers. --dry-run reports what would change without writing files. The first shipped rule, unused_import, removes unused use statements project-wide, collapsing blank lines left behind by removals. Supports path filtering and single-file mode.
• Keyword completions. Context-aware PHP keyword suggestions filtered by scope (e.g. return only inside functions, break only inside loops, member keywords inside class bodies, enum backing types after enum Name:). Contributed by @ryangjchandler in #43.
• Attribute completion. Typing inside #[…] offers only classes decorated with #[\Attribute], filtered by the target declaration kind.
• Eloquent model enhancements. Timestamp properties (created_at, updated_at) are automatically typed as Carbon with support for $timestamps = false and custom column constants. Legacy $dates arrays produce typed virtual properties. $appends entries produce virtual properties. where{PropertyName}() dynamic methods are synthesized from all known columns (including @property annotations) on both the model and the Builder. whereHas/whereDoesntHave closure parameters resolve to Builder<RelatedModel> by traversing relationship methods, with dot-notation chain support. Conditionable::when()/unless() chains preserve type information.
• Type-guard narrowing. is_array(), is_string(), is_int(), is_float(), is_bool(), is_object(), is_numeric(), and is_callable() narrow union types inside if/else/elseif bodies and after guard clauses, preserving generic element types through narrowing.
• Array value type tracking. Arrays built incrementally with variable keys inside loops now carry element types through foreach iteration, bracket access, and null-coalescing. Foreach over generic arrays with non-class element types (array shapes, scalars) now preserves the full element type.
• Inherited docblock type propagation. When a child class overrides a method without providing its own @return or @param docblock, the ancestor's richer types flow through automatically. Applies to return types, parameter types (matched by position), property type hints, and descriptions.
• Bidirectional template inference from closures. Templates appearing in callable parameter signatures are now inferred from both the closure's return type and its parameter types. Positional matching is supported, and return-type bindings take priority when the same template appears in both positions.
• Drupal project support. Drupal projects are detected via composer.json. Drupal-specific directories and PHP extensions (.module, .install, .theme, .profile, .inc, .engine) are recognized and indexed. Contributed by @syntlyx in #52.
• Completion and signature help for new self, new static, and new parent. Constructor parameter snippets and signature help inside the parentheses. Contributed by @RemcoSmitsDev in #51.
• Hover on parameter variables at their definition site. Hovering on a function or method parameter now shows its resolved type, using the @param docblock type when it is richer than the native hint. Contributed by @RemcoSmitsDev in #68.
• Array element type extraction from property generics. Bracket access on properties annotated with generic array or collection types (e.g. $this->cache[$key]->) now resolves the element type correctly through nested chains, string-literal keys, and method chains after the bracket.
• @phpstan-assert-if-true $this narrowing. Instance methods annotated with @phpstan-assert-if-true or @phpstan-assert-if-false targeting $this now narrow the receiver variable in the corresponding branch. Contributed by @syntlyx in #52.
• Namespace completion from file path. When creating a new PHP file, typing namespace suggests the correct namespace inferred from the file's location and the project's PSR-4 autoload mappings. The most specific mapping is preselected so you can accept it with a single keypress. When multiple PSR-4 roots match the same directory, all candidates appear ranked by specificity (longest match first).
• Standalone @var docblock for untyped closure parameters. When a closure parameter lacks a type hint and no assignment follows, a @var block above the usage is now picked up as the variable's type.
• --stdio CLI flag. Accepted (and ignored) for compatibility with LSP client wrappers that pass --stdio by default.
• --tcp CLI flag. phpantom_lsp --tcp 9257 starts the server listening on a TCP port instead of stdin/stdout. Useful for debugging or connecting from IDE plugins that prefer a network transport over spawning a child process. Accepts a full address (127.0.0.1:9257) or just a port number. The server accepts one connection and exits when the client disconnects.
• Method-level template parameters resolve inside method bodies. @template T of Builder with @param T $query now resolves $query to the template bound inside the method body, providing completions from the bound class.
• Undefined variable diagnostic. Variable reads that have no prior definition (assignment, parameter, foreach binding, catch variable, global, static, use() clause, or destructuring) in the same scope are flagged as errors. Writes must appear before the read in source order, catching use-before-assign bugs, while assignments inside branches (if/else, switch, try/catch) still count to avoid false positives. Suppressed for superglobals, isset()/empty() guards, compact() references, extract() calls, variable variables ($$), @ error suppression, and @var annotations. Static property accesses (self::$prop, static::$prop, parent::$prop) are excluded. Variables passed to by-reference parameters are recognized as definitions: 40+ built-in PHP functions are covered (regex, cURL, OpenSSL, sockets, DNS, etc.), and user-defined functions, static methods, and constructors with &$param parameters are detected automatically from their signatures. Scoping is tracked through arbitrary nesting of closures, arrow functions, and catch blocks. Top-level code outside functions is skipped.
• By-reference parameter type inference for method, static, and constructor calls. When a variable is passed to a by-reference parameter with a type hint (e.g. function foo(Baz &$bar)), the variable acquires that type after the call. Previously this only worked for standalone function calls. Now it also works for $this->method(), static method calls, and constructor calls.

Changed

• Fewer false-positive diagnostics. Variable resolution now produces the same result across completions, hover, and diagnostics, eliminating cases where diagnostics disagreed about a variable's type.
• @phpstan-ignore is never the preferred quickfix. The "Ignore PHPStan error" code action is explicitly non-preferred, so editor keyboard shortcuts no longer accidentally apply it when another fix is available.
• Generate PHPDoc infers @return from the function body. Typing /** above a function that returns array now produces a specific element type (e.g. @return list<string>) instead of @return array<mixed>.
• Faster startup. Stub loading during initialization is significantly faster.
• More accurate generics resolution. Type substitution and resolution for complex nested generic types is more correct, particularly for unions, intersections, array shapes, and deeply nested generic arguments.
• More accurate type predicates. NULL, Null, and case variants of null are now handled consistently throughout type checking, matching PHP's case-insensitive treatment of type keywords.
• Go-to-definition at declaration sites returns the symbol's own location. Class, member, and variable declaration names now return their own location instead of nothing, so editors that detect "definition == cursor" can automatically fall back to Find References. Contributed by @lucasacoutinho in #76.

Fixed

• Completion no longer triggers on the <?php open tag. Typing <?php and pressing enter no longer applies a spurious function suggestion like `...

0.6.0

What's Changed

Added

• Semantic Tokens. Type-aware syntax highlighting that goes beyond what a TextMate grammar can achieve. Classes, interfaces, enums, traits, methods, properties, parameters, variables, functions, constants, and template parameters all get distinct token types. Modifiers convey declaration sites, static access, readonly, deprecated, and abstract status.
• PHPStan diagnostics. PHPStan errors appear inline as you edit. Auto-detects vendor/bin/phpstan or $PATH. Runs in the background without blocking native diagnostics. Configurable via [phpstan] in .phpantom.toml (command, memory-limit, timeout). "Ignore PHPStan error" and "Remove unnecessary @phpstan-ignore" code actions manage inline ignore comments.
• Formatting. Built-in PHP formatting (PER-CS 2.0 style). Formatting works out of the box without any external tools. Projects that depend on php-cs-fixer or PHP_CodeSniffer in their composer.json require-dev automatically use those tools instead (both can run in sequence). Per-tool command overrides and disable switches in [formatting] in .phpantom.toml.
• Inlay hints. Parameter name and by-reference indicators appear at call sites. Hints are suppressed when the argument already makes the parameter obvious: variable names matching the parameter, property accesses with a matching trailing identifier, string literals whose content matches, well-known single-parameter functions like count and strlen, and spread arguments. Named arguments never receive a redundant hint.
• PHPDoc block generation. Typing /** above any declaration generates a docblock skeleton. Tags are only emitted when the native type hint needs enrichment. Properties and constants always get @var. Class-likes with templated parents or interfaces get @extends/@implements tags. Uncaught exceptions get @throws with auto-import. Works both via completion and on-type formatting.
• Syntax error diagnostic. Parse errors from the Mago parser now appear as Error-severity diagnostics instantly as you type.
• Implementation error diagnostic. Concrete classes that fail to implement all required methods from their interfaces or abstract parents are now flagged with an Error-severity diagnostic on the class name. The existing "Implement missing methods" quick-fix appears inline alongside the error.
• Argument count diagnostic. Flags function and method calls that pass too few arguments. The "too many arguments" check is off by default (PHP silently ignores extra arguments) and can be enabled with extra-arguments = true in the [diagnostics] section of .phpantom.toml.
• Completion item documentation. Selecting a completion item in the popup now shows rich documentation including the full typed signature, description, deprecation notice, and parameter details. Previously only the class name was shown.
• Method commit characters. Typing ( while a method completion is highlighted auto-accepts it and begins the argument list.
• Document Symbols. The outline sidebar and breadcrumbs now show classes, interfaces, traits, enums, methods, properties, constants, and standalone functions with correct nesting, icons, visibility detail, and deprecation tags.
• Workspace Symbols. "Go to Symbol in Workspace" (Ctrl+T / Cmd+T) searches across all indexed files including vendor classes. Results include namespace context and deprecation markers, sorted by relevance.
• Type Hierarchy. "Show Type Hierarchy" on any class, interface, trait, or enum reveals its supertypes and subtypes with full up-and-down navigation through the inheritance tree, including cross-file resolution and transitive relationships.
• Code Lens. Clickable annotations above methods that override a parent class method or implement an interface method. Clicking navigates to the prototype declaration.
• Update docblock. Code action on a function or method whose existing docblock is out of sync with its signature. Adds missing @param tags, removes stale ones, reorders to match the signature, fixes contradicted types, and removes redundant @return void. Refinement types and unrelated tags are preserved. Only triggers on the signature or the preceding docblock, not inside the function body.
• Change visibility. Code action on any method, property, constant, or promoted constructor parameter offers to change its visibility (public, protected, private). Only triggers on the declaration signature, not inside the body.
• @throws code actions. Quick-fixes for adding missing and removing unnecessary @throws tags, triggered by PHPStan diagnostics. Adding inserts the tag and a use import when needed. Removing cleans up orphaned blank lines and deletes the entire docblock when it would be empty. The diagnostic disappears on the next keystroke without waiting for the next PHPStan run.
• File rename on class rename. Renaming a class whose file follows PSR-4 naming now also renames the file to match. The file is only renamed when it contains a single class-like declaration and the editor supports file rename operations.
• Folding Ranges. AST-aware code folding for class bodies, method/function bodies, closures, arrays, argument/parameter lists, control flow blocks, doc comments, and consecutive single-line comment groups.
• Selection Ranges. Smart select / expand selection returns AST-aware nested ranges from innermost to outermost.
• Document Links. require/include paths are now Ctrl+Clickable. Path resolution supports string literals, __DIR__ concatenation, dirname(__DIR__), dirname(__FILE__), and nested dirname with levels.
• Analyze command. phpantom_lsp analyze scans a Composer project and reports PHPantom's own diagnostics in a PHPStan-like table format. Useful for measuring type coverage across an entire codebase without opening files one by one. Accepts an optional path argument to limit the scan to a single file or directory. Output includes diagnostic identifiers and supports --severity filtering and --no-colour for CI.
• Null-coalesce (??) type refinement. When the left-hand side of ?? is provably non-nullable (e.g. new Foo(), clone $x, a literal), the right-hand side is recognized as dead code and the result resolves to the LHS type only. When the LHS is nullable (e.g. a ?Foo return type), null is stripped from the LHS and the result is the union of the non-null LHS with the RHS.
• @mixin generic substitution. When a class declares @mixin Foo<T>, the generic arguments are now preserved and substituted into the mixin's members, including through multi-level inheritance chains.
• PHPDoc @var completion. Inline @var above variable assignments sorts first and pre-fills the inferred type when available. Template parameters from @template enrich @param, @return, and @var type hints.
• @see and @link improvements. @see references in docblocks now work with go-to-definition (class, member, and function forms). Hover popups show all @link and @see URLs as clickable links. Deprecation diagnostics include @see targets when the @deprecated docblock references them.
• Progress indicators. Go to Implementation and Find References now show a progress indicator in the editor while scanning.
• Phar archive class resolution. Classes inside .phar archives (e.g. PHPStan's phpstan.phar) are now discovered and indexed automatically. No PHP runtime needed. Only uncompressed phars are supported (the format used by PHPStan and most other phar-distributed tools).
• PSR-0 autoload support. Packages that use the legacy PSR-0 autoloading standard are now discovered automatically.
• Global config. Settings from a global .phpantom.toml in the user's config directory (typically ~/.config/phpantom_lsp/.phpantom.toml) are now loaded as defaults. Project-level configs take precedence. By @calebdw in #39
• Config schema. A JSON schema for .phpantom.toml is now bundled, enabling autocompletion and validation in editors that support TOML schemas. By @calebdw in #38

Changed

• Pull diagnostics. Diagnostics are now delivered via the LSP 3.17 pull model when the editor supports it. The editor requests diagnostics only for visible files, and cross-file invalidation no longer recomputes every open tab. Clients without pull support fall back to the previous push model automatically.
• Hover type accuracy. Hover now resolves variable types through the same pipeline as completion, so all narrowing features (instanceof, assert, custom type guards, in_array) apply. When the cursor is inside a specific if/else branch, hover shows only the type visible in that branch. Complex expressions like null-coalesce chains, array shapes, empty arrays, and unresolved symbols all display correctly.
• Version-aware stub types. Built-in function signatures that changed across PHP versions (e.g. int|false in 7.x becoming int in 8.0) now show the correct type for your project's PHP version. This eliminates false-positive diagnostics and incorrect completions from stale type annotations.
• Completion labels. Method and function completion items now show only parameter names in the label (e.g. setName($name)) with the return type displayed inline (e.g. : User). Properties and constants show just the type hint. The previous Class: ClassName detail line has been removed; class context is available in the documentation panel when the item is highlighted.
• Completion sort order. Member completion items are now sorted by kind (constants, then properties, then methods) before alphabetical order within each group. Union-type completions apply the same kind-based ordering within both the intersection and branch-only tiers.
• **Class name completion ran...

0.5.0

Added

• Diagnostics. Unknown classes, unknown members, and unknown functions are flagged with appropriate severity. An opt-in unresolved member access diagnostic is available via .phpantom.toml.
• Find References. Locate every usage of a symbol across the project. Supports classes, methods, properties, constants, functions, and variables. Variable references are scoped to the enclosing function or closure. Member references are scoped to the class hierarchy, so unrelated classes sharing a method name are excluded.
• Rename. Rename variables, classes, methods, properties, functions, and constants across the workspace. Variable renames are scoped to their enclosing function or closure.
• Deprecation support. @deprecated tags and #[Deprecated] attributes surface in hover, completion strikethrough, and diagnostics. A quick-fix code action rewrites deprecated calls when a replacement template is available.
• Document highlighting. Placing the cursor on a symbol highlights all occurrences in the current file. Variables are scoped to their enclosing function or closure with write vs. read distinction.
• Implement missing methods. Code action that generates method stubs when a class is missing required interface or abstract method implementations.
• Project configuration. .phpantom.toml for per-project settings: PHP version override, diagnostic toggles, and indexing strategy. Run phpantom --init to generate a default config.
• Reverse go-to-implementation. Go-to-implementation on a concrete method jumps to the interface or abstract class that declares the prototype, and vice versa.
• Go to Type Definition. Jump from a variable, property, method call, or function call to the class declaration of its resolved type. Union types produce multiple locations.
• Self-generated classmap. PHPantom works without composer dump-autoload -o. Missing or incomplete classmaps are supplemented by scanning autoload directories. Non-Composer projects are supported by scanning all PHP files.
• Monorepo support. Discovers subdirectories that are independent Composer projects and processes each through the full pipeline.
• @implements generic resolution. @implements Interface<ConcreteType> substitutes template parameters on the interface's methods and properties. Foreach iteration on generic iterable interfaces resolves value and key types.
• Interface template inheritance. Implementing classes inherit @template parameters, bindings, conditional return types, and type assertions from their interfaces.
• Function-level @template with generic return types. Functions that use @template parameters inside generic return types now resolve concrete types from call-site arguments.
• Generic @phpstan-assert with class-string<T>. Assertion methods that accept a class-string<T> parameter resolve the narrowed type from the call-site argument.
• Property-level narrowing. if ($this->prop instanceof Foo) narrows $this->prop in then/else bodies and after guard clauses.
• Inline && short-circuit narrowing. The right-hand side of && now sees the narrowed type from the left-hand side.
• Compound negated guard clause narrowing. if (!$x instanceof A && !$x instanceof B) { return; } narrows $x to A|B in the surviving code.
• Closure variable scope isolation. Variables outside a closure are no longer offered as completions unless captured via use().
• Pipe operator (PHP 8.5). $input |> trim(...) |> createDate(...) resolves through the chain.
• AST-based array type inference. Array shape keys, element access, spread elements, and push-style assignments all resolve through an AST walker.
• new $classStringVar and $classStringVar::method(). Class-string variables resolve for new and static member access.
• Invoked closure and arrow function return types. (fn(): Foo => ...)() and (function(): Bar { ... })() resolve to their return type.
• Docblock navigation. Go-to-definition and hover work on class names inside callable types, array/object shape value types, and object shape properties.
• GTD from parameter and property variables. Clicking a parameter or property at its definition site jumps to the type hint class.
• PHP version-aware stubs. Detects the target PHP version from composer.json and filters built-in stub signatures accordingly.
• @param-closure-this. $this inside a closure resolves to the type declared by @param-closure-this on the receiving parameter.
• Non-Composer function and constant discovery. Cross-file function completion, go-to-definition, and constant resolution for projects without composer.json.
• Indexing progress indicator. The editor shows a progress bar during workspace initialization, including per-subproject progress in monorepos.
• Pass-by-reference parameter type inference. After calling a function with a typed &$var parameter, the variable acquires that type.
• iterator_to_array() element type. Resolves the element type from the iterator's generic annotation.
• Enum case properties. $case->name and $case->value resolve on enum case variables.
• Inline @var on promoted constructor properties. Overrides the native type hint, matching existing @param support.
• --version and --help CLI flags. Contributed by @calebdw in #7.

Changed

• Resolution engine rewritten on AST. Variable type inference, call return types, and go-to-definition all run through the AST walker for better accuracy.
• Hover redesigned. Short names with namespace line, actual default values, @link URLs, precise token highlighting, constructor signatures on new, @template details, enum case listing, trait member listing, origin indicators, and deprecated explanations.
• Signature help enriched. Compact parameter list with native types, per-parameter @param descriptions, default values, and attribute parenthesis support.
• Faster resolution and lower memory usage.
• Parallel workspace indexing. File parsing, PSR-4 scanning, and vendor scanning run across all CPU cores. .gitignore rules are respected.
• Two-phase diagnostic publishing. Cheap diagnostics (unused imports, deprecation) publish immediately; expensive diagnostics (unknown classes/members/functions) arrive in a second pass.
• Merged classmap + self-scan pipeline. Composer classmaps and self-scanning work together instead of being mutually exclusive. Stale classmaps are supplemented automatically.
• Automatic stub fetching. The build script downloads phpstorm-stubs automatically when missing. Composer is no longer needed to build PHPantom. Contributed by @calebdw in #16.
• Feature comparison table corrected. Phactor capabilities updated in the README. Contributed by @dantleech in #10.

Fixed

• Cross-file inheritance from global-scope classes imported via use.
• Inherited @method and @property tags across files.
• Diagnostics refresh across open files when a class signature changes.
• Variable types resolve through ternary, elvis, null-coalesce, and match assignments.
• instanceof narrowing no longer widens specific types.
• Elseif chain narrowing and sequential assert narrowing.
• @phpstan-type aliases in foreach, list(), and key types.
• False-positive unknown-class warnings on PHPStan type syntax.
• Go-to-implementation no longer produces false positives across namespaces.
• __invoke() return type resolution. Works with chaining, foreach, and parenthesized invocations.
• Enum from() and tryFrom() chaining.
• static/self/$this in method return types used as iterable expressions.
• Mixed -> then :: accessor chains.
• Inline (new Foo)->method() chaining.
• ?-> null-safe chain resolution.
• Array function resolution for array_pop, array_filter, array_values, end, array_map.
• Inline @var annotations no longer leak across scopes.
• Literal string conditional return types.
• Class constant and enum case assignment resolution.
• Go-to-definition on trait as alias and insteadof declarations.
• Inline array-element function calls resolve correctly in diagnostics. end($obj->items)->method() no longer produces a false diagnostic.
• Double-negated instanceof narrowing.
• Self-referential array key assignments no longer crash.

New Contributors

• @calebdw made their first contribution in #7
• @dantleech made their first contribution in #10

Full Changelog: 0.4.0...0.5.0

0.4.0

Added

• Signature help. Parameter hints in function/method calls with active parameter highlighting.
• Hover. Type, signature, and docblock in a Markdown popup for all symbol kinds.
• Closure and callable inference. Untyped closure parameters inferred from the callable signature. First-class callable syntax resolves return types.
• Laravel Eloquent. Relationships, scopes, Builder forwarding, factories, custom collections, casts, accessors, mutators, $attributes, and $visible.
• Type narrowing. in_array() with strict mode, early return guards, instanceof in ternaries and with interfaces.
• Anonymous class support. $this-> resolves inside anonymous classes with full inheritance support.
• Context-aware completions. extends, implements, use inside class body, union member sorting, namespace segments, string literal suppression.
• Additional resolution. Multi-line chains, nested array keys, generator yield types, conditional return types with template substitution, switch/unset variable tracking.
• Transitive interface go-to-implementation.

Fixed

• Visibility filtering, scope isolation, static call chains, static return type, trait resolution, mixin fluent chains, go-to-definition accuracy, import handling, UTF-8 boundaries, and parenthesized RHS expressions.

0.3.0

Added

• Go-to-implementation. Interface/abstract class to all concrete implementations.
• Method-level @template. Infers T from the call-site argument.
• @phpstan-type / @psalm-type aliases and @phpstan-import-type.
• Array function type preservation. array_filter, array_map, array_pop, current, etc.
• Early return narrowing. Guard clauses narrow types for subsequent code.
• Callable variable invocation. $fn()-> resolves return types.
• Additional resolution. Spread operators, trait insteadof/as, chained assignments, destructuring, foreach on function returns, type hint completion, try-catch suggestions.

Fixed

• PHPDoc type parsing and internal stability fixes.

0.2.0

Added

• Generics. Class-level @template with @extends substitution. Method-level class-string<T>. Generic trait substitution.
• Array shapes and object shapes. Key completion from literals, incremental assignments, destructuring, element access.
• Foreach type resolution. Generic iterables, array shapes, Collection<User>, Generator<int, Item>, IteratorAggregate.
• Expression type inference. Ternary, null-coalescing, and match expressions.
• Additional completions. Named arguments, variable name suggestions, standalone functions, define() constants, PHPDoc tags, deprecated members, promoted property types, property chaining, require_once discovery, go-to type definition.

Fixed

• @mixin context for return types, global class imports, namespace resolution, and aliased class go-to-definition.

0.1.0

Initial release.

Added

• Completion. Methods, properties, and constants via ->, ?->, and :: with visibility filtering.
• Type resolution. Inheritance merging, self/static/parent, union types, nullsafe chains.
• PHPDoc support. @return, @property, @method, @mixin, conditional return types, inline @var.
• Type narrowing. instanceof, is_a(), @phpstan-assert.
• Enum support. Case completion and UnitEnum/BackedEnum interface members.
• Go-to-definition. Classes, methods, properties, constants, functions, new expressions, variables.
• Class name completion with auto-import.
• PSR-4 lazy loading and Composer classmap support.
• Embedded phpstorm-stubs.
• Zed editor extension.