Fortran — 135 Operations for AI Agents

This page is the canonical reference an AI coding agent uses to refactor, query, and analyze Fortran code through the act MCP server. 135 operations available: 61 refactor, 18 query, 42 analysis, 14 verification. Each operation is callable from Claude Code, Cursor, Codex, OpenCode, or any MCP-compatible agent host. Click any operation for a stable anchor link suitable for citation.

Premium language. Operations on Fortran require an Elite license or above. See pricing.

18Query

61Refactor

42Analysis

14Verify

Worked Fortran examples

act101 edits Fortran source at the declaration and control-flow level: it can add an ALLOCATABLE attribute to an array declaration, generate a module skeleton at a chosen point in a file, and convert a computed GOTO into a SELECT CASE construct. Each operation locates its target — a declaration, an insertion point, a GOTO statement — by walking the parsed source, so the same operation applies whether the file is a bare subroutine or a module with several. Fortran code frequently carries decades of legacy control flow, so act101's conversion operations rewrite the outdated construct into its modern equivalent without touching the surrounding logic. Each example below is the verbatim output of the command shown, run against the file shown.

Add an ALLOCATABLE attribute to an array declaration

mymod.f90 declares module mymod holding one fixed-size array, real :: data(100).

$ act refactor-lang add_allocatable_attribute --file mymod.f90 --params '{"line":3,"column":3}'

Before

module mymod
  implicit none
  real :: data(100)
end module mymod

After

module mymod
  implicit none
  real, allocatable :: data(:)
end module mymod

real :: data(100) becomes real, allocatable :: data(:) — the fixed extent is replaced by a deferred shape, so the array is sized at run time by an allocate statement instead of at compile time.

Generate a module skeleton

physics.f90 holds a single comment line, ! Physics utilities, and no program unit yet.

$ act refactor-lang generate_module_structure --file physics.f90 --params '{"line":2,"name":"physics_module","column":1}'

Before

! Physics utilities

After

! Physics utilities
module physics_module
  implicit none

contains

end module physics_module

A module physics_module / implicit none / contains / end module physics_module skeleton is inserted after the comment, ready for procedures to be added under its contains.

Convert a computed GOTO to SELECT CASE

dispatch.f90 defines subroutine dispatch(n), which dispatches on n with a computed goto (10, 20, 30) n.

$ act refactor-lang convert_computed_goto --file dispatch.f90 --params '{"line":4,"column":3}'

Before

subroutine dispatch(n)
  implicit none
  integer :: n
  goto (10, 20, 30) n
10 print *, 'case 1'
20 print *, 'case 2'
30 print *, 'case 3'
end subroutine dispatch

After

subroutine dispatch(n)
  implicit none
  integer :: n
  select case (n)
  case (1)
    goto 10
  case (2)
    goto 20
  case (3)
    goto 30
  end select
10 print *, 'case 1'
20 print *, 'case 2'
30 print *, 'case 3'
end subroutine dispatch

The goto (10, 20, 30) n becomes a select case (n) with one case per label, each branch still goto-ing to its original numbered statement.

Query

18 query tools, the same on every supported language. Descriptions live in the shared reference: /docs/query-tools.

callers control_flow data_flow definition diagnostics effect_closure effect_summary fix_auto get_type graph import_organize interface mutations references repo_outline skeleton symbols symbols_batch

Refactor

Operation	Description
`add-allocatable-attribute`	Add ALLOCATABLE attribute for dynamic memory
`add-assumed-shape-attribute`	Add assumed-shape array declaration with deferred dimensions
`add-asynchronous-attribute`	Add ASYNCHRONOUS attribute for non-blocking I/O variables
`add-bind-c-attribute`	Add BIND(C) attribute for C interoperability
`add-codimension-attribute`	Add CODIMENSION attribute for coarray variables
`add-contiguous-attribute`	Add CONTIGUOUS attribute for pointer or assumed-shape arrays
`add-dimension-attribute`	Add DIMENSION attribute to array declaration
`add-end-statement`	Add END statement to program unit or construct
`add-entry-statement`	Add ENTRY statement to subroutine or function
`add-external-declaration`	Add EXTERNAL declaration for external subprogram
`add-implicit-none`	Add IMPLICIT NONE to module or program
`add-intent`	Add INTENT attribute to subroutine argument
`add-only-to-use-statement`	Add ONLY clause to existing USE statement
`add-optional-attribute`	Add OPTIONAL attribute to subroutine dummy argument
`add-parameter-attribute`	Add PARAMETER attribute to compile-time constant
`add-protected-attribute`	Add PROTECTED attribute to module variable
`add-public-private-statements`	Add explicit PUBLIC/PRIVATE access modifiers
`add-recursive-modifier`	Add RECURSIVE modifier to subroutine or function
`add-save-attribute`	Add SAVE attribute to local variable
`add-target-attribute`	Add TARGET attribute to variable that may be pointed to
`add-use-only-statement`	Convert USE statement to USE ONLY with explicit imports
`add-value-attribute`	Add VALUE attribute to dummy argument for pass-by-value
`change-accessibility`	Change PUBLIC/PRIVATE accessibility
`convert-array-element-to-pointer`	Convert array element access to POINTER association
`convert-character-to-string`	Convert CHARACTER to modern string representation
`convert-common-to-module`	Convert COMMON block to MODULE with module variables
`convert-computed-goto`	Convert computed GOTO to SELECT CASE construct
`convert-contains-to-interface`	Convert CONTAINS section to explicit INTERFACE block
`convert-do-concurrent-to-do`	Convert DO CONCURRENT loop to standard DO loop
`convert-do-to-do-while`	Convert indexed DO loop to DO WHILE loop
`convert-do-while-to-do`	Convert DO WHILE loop to indexed DO loop
`convert-elemental-to-pure`	Replace ELEMENTAL qualifier with PURE so array arguments no longer work element-wise
`convert-fixed-form-to-free-form`	Convert fixed-form Fortran source layout to free-form
`convert-goto-to-if`	Convert unconditional GOTO to structured IF block
`convert-if-to-select-case`	Convert IF-ELSE chain to SELECT CASE
`convert-implicit-to-explicit-typing`	Convert implicit typing to explicit typing by adding IMPLICIT NONE
`convert-implicit-to-none`	Convert implicit typing to explicit IMPLICIT NONE declarations
`convert-pure-to-elemental`	Replace PURE qualifier with ELEMENTAL so array arguments work element-wise
`convert-string-to-character`	Convert string literal to CHARACTER type
`extract-constant`	Extract a literal into a named PARAMETER at the resolved specification-part position
`extract-function`	Extract selected statements into an internal subroutine under CONTAINS
`extract_function`	Extract a code selection into a new function — automatically infers parameters, return types, and inserts the call site. Use instead of manually cutting/pasting code. Works without LSP; LSP improves type inference. Params: file (string), new_name (string), start_line (u32), start_column (u32), end_line (u32), end_column (u32) [, preview (bool), receipt (bool)]
`extract_variable`	Extract an expression into a named variable — inserts the declaration and replaces the expression with the variable name. Works without LSP. Params: file (string), new_name (string), start_line (u32), start_column (u32), end_line (u32), end_column (u32) [, preview (bool)]
`generate-allocation-code`	Generate safe allocation code for an allocatable variable
`generate-deallocation-code`	Generate safe deallocation code for an allocatable variable
`generate-derived-type`	Generate a Fortran derived-type skeleton
`generate-module-structure`	Generate a Fortran module skeleton
`generate-subroutine-stub`	Generate subroutine with parameter list
`inline`	Inline a variable, function, or method — replace every usage with its definition body, then remove the original. The inverse of extract. Works without LSP (single-file); LSP enables cross-file inlining. Params: file (string), symbol (string) [, line (u32), preview (bool), receipt (bool)]
`insert_body`	Replace a function's implementation body with new code. AST-validated — rejects if the result has parse errors, so you can't accidentally break syntax. Use instead of manual text editing for function rewrites. Params: file (string), symbol (string), code (string) [, commit (bool)]
`move_symbol`	Move a function, class, or type to a different file and automatically update all imports across the codebase. Use instead of manually cut/paste + fixing imports. Works without LSP (single-file); LSP enables cross-file import updates. Params: file (string), symbol (string), destination (string) [, preview (bool), receipt (bool)]
`recipe_run`	Run a codemod recipe: declarative match → transform → optional verify across modeled grammars. Preview lists matches; apply writes with optional E7 receipts and all-or-nothing rollback. Returns a per-site report.
`remove-dead-code`	Remove unreachable code after unconditional transfer statement
`remove-goto`	Remove simple unconditional GOTO statement
`remove-only-from-use-statement`	Remove ONLY clause from USE statement to import all symbols
`remove-recursive-modifier`	Remove RECURSIVE modifier from subroutine or function
`remove-save-attribute`	Remove SAVE attribute from local variable
`remove-unnecessary-use`	Remove unused USE statement
`rename`	Rename a symbol and automatically update ALL references across the codebase. Safer and faster than find-and-replace — AST-aware, won't rename strings or comments. Works without LSP (single-file); LSP enables cross-file renames. Params: file (string), old_name (string), new_name (string) [, line (u32), column (u32), preview (bool), receipt (bool)]
`reorder-use-statements`	Sort and group USE statements alphabetically
`wrap-in-module`	Wrap standalone program unit in a Fortran module

Analysis

42 analysis tools, the same on every supported language. Descriptions live in the shared reference: /docs/analysis-tools.

analyze_api_diff analyze_chokepoints analyze_clones analyze_clusters analyze_cohesion analyze_conformance analyze_coupling analyze_cycle_risk analyze_cycles analyze_dead_code analyze_depth analyze_entry_points analyze_export analyze_extraction analyze_fan_balance analyze_features analyze_hotspots analyze_impact analyze_inconsistencies analyze_inheritance analyze_interface_bloat analyze_interfaces analyze_layers analyze_orphan_types analyze_patterns analyze_platform_deps analyze_readiness analyze_roles analyze_seams analyze_stability analyze_surface analyze_test_gaps analyze_thickness analyze_type_completeness churn_hotspots co_change_clusters coverage_overlay ownership_map profile_overlay simulate split_module trace_overlay

Verify

14 verify tools, the same on every supported language. Descriptions live in the shared reference: /docs/verification.

bisect_regression gate generate_test_harness scan secret_surface summarize_pr taint_flow unsafe_surface verify_behavioral_equivalence verify_contract_preserved verify_diff_semantics verify_port_parity verify_side_effects verify_test_impact

← FIRRTLF# →