fortrangoingonforty/facsimile / d3256e4

+| `F12` or `Ctrl+\` | Go to Definition | Jump to where a symbol is defined |

+| `Shift+F12` or `Ctrl+Shift+R` | Find References | Find all usages of a symbol |

+| `F8` or `Ctrl+Shift+D` | Diagnostics Panel | Show all errors and warnings |

+| `F4` or `Ctrl+Shift+O` | Document Symbols | Navigate symbols in current file |

+| `F6` or `Ctrl+Shift+T` | Workspace Symbols | Search symbols across all files |

+| `Ctrl+P` | Command Palette | Search and execute any command |

+| `F6ab` | Previous Tab | Switch to previous tab |

+| `Ctrl+P` | Command Palette | Search and execute any command |

+- Common conflicts: `F6` (new terminal tab), `Ctrl+W` (close terminal tab)

+- Use `Ctrl+P` (Command Palette) to see all available commands

+1. `F6` - Find any symbol in project

+1. `F8` - See all errors

+2. **View all diagnostics**: Press `F8` to open the diagnostics panel

+- Press `F8` to open the **Diagnostics Panel** showing all issues

+- `F8` or `Ctrl+Shift+D` - Open/close diagnostics panel

+- `F12` or `Ctrl+\` - Go to definition

+- `Shift+F12` or `Ctrl+Shift+R` - Find all references

+### 6. Document Symbols Outline (F4)

+1. Press `F4` to open the symbols panel

+- `F4` or `Ctrl+Shift+O` - Open document symbols panel

+### 7. Workspace Symbols (F6)

+1. Press `F6` to open workspace symbols

+- `F6` or `Ctrl+Shift+T` - Open workspace symbols

+### 10. Command Palette (Ctrl+P)

+1. Press `Ctrl+P`

+- `Ctrl+P` - Open command palette

+- `F4` - Search symbols in current file

+- `F6` - Search symbols across project

+1. Press `F8` to see all errors

+| **Diagnostics Panel** | `F8` or `Ctrl+Shift+D` | Show all errors/warnings |

+| **Go to Definition** | `F12` or `Ctrl+\` | Jump to where symbol is defined |

+| **Find References** | `Shift+F12` or `Ctrl+Shift+R` | Find all usages of symbol |

+| **Document Symbols** | `F4` or `Ctrl+Shift+O` | Outline of current file |

+| **Workspace Symbols** | `F6` or `Ctrl+Shift+T` | Search symbols across project |

+| **Command Palette** | `Ctrl+P` | Access all commands |

+3. **Explore your codebase** with `F6` and `F12`

+        ! DEBUG: Log ALL keys to file only (not screen to avoid overwriting status messages)

+        block

+            integer :: debug_unit

+            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+            write(debug_unit, '(A)') '[KEY] "' // trim(key_str) // '"'

+            close(debug_unit)

+        end block

+

+        ! Route input when in fuss mode (except ctrl-b/ctrl-shift-b/F-keys/Alt-keys/ctrl-q which work in both modes)

+            trim(key_str) /= 'f3' .and. trim(key_str) /= 'f4' .and. &

+            trim(key_str) /= 'f6' .and. trim(key_str) /= 'f8' .and. &

+            trim(key_str) /= 'f12' .and. trim(key_str) /= 'shift-f12' .and. &

+            trim(key_str) /= 'alt-g' .and. trim(key_str) /= 'alt-o' .and. &

+            trim(key_str) /= 'alt-p' .and. trim(key_str) /= 'alt-e' .and. &

+            trim(key_str) /= 'alt-r' .and. trim(key_str) /= 'ctrl-\\' .and. &

+            trim(key_str) /= 'ctrl-q') then

+        case('f12', 'ctrl-\\', 'alt-g')

+            ! Go to definition (F12, Ctrl+\, or Alt+G)

+            block

+                integer :: debug_unit

+                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+                write(debug_unit, '(A)') '>>> INSIDE F12/ALT-G HANDLER <<<'

+                write(debug_unit, '(A,I0)') 'active_tab_index = ', editor%active_tab_index

+                write(debug_unit, '(A,I0)') 'size(tabs) = ', size(editor%tabs)

+                if (editor%active_tab_index > 0 .and. editor%active_tab_index <= size(editor%tabs)) then

+                    write(debug_unit, '(A,I0)') 'lsp_server_index = ', editor%tabs(editor%active_tab_index)%lsp_server_index

+                end if

+                close(debug_unit)

+            end block

+            call terminal_move_cursor(editor%screen_rows, 1)

+                        ! Save editor state for callback

+                        if (.not. allocated(saved_editor_for_callback)) then

+                            allocate(saved_editor_for_callback)

+                        end if

+                        saved_editor_for_callback = editor

+

+                            lsp_line, lsp_char, handle_definition_response_wrapper)

+

+                        block

+                            integer :: debug_unit

+                            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+                            write(debug_unit, '(A,I0)') 'request_definition returned request_id = ', request_id

+                            close(debug_unit)

+                        end block

+                        else

+                            call terminal_write('[F12] LSP request failed                    ')

+                else

+                    call terminal_write('[F12] No LSP server for this file           ')

+            else

+                call terminal_write('[F12] No active tab                         ')

+        case('shift-f12', 'alt-r')

+            ! Find all references (Shift+F12 or Alt+R)

+        case('f4', 'alt-o')

+            ! Document symbols outline (F4 or Alt+O)

+            block

+                integer :: debug_unit

+                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+                write(debug_unit, '(A)') '>>> INSIDE F4/ALT-O HANDLER <<<'

+                close(debug_unit)

+            end block

+        case('ctrl-p')

+            ! Command palette (Ctrl+P - VSCode standard)

+            ! Note: ctrl-shift-p doesn't work - terminals can't distinguish ctrl-p from ctrl-shift-p

+        case('f6', 'alt-p')

+            ! Workspace symbols (F6 or Alt+P for project)

+        case('f8', 'alt-e')

+            ! Toggle diagnostics panel (F8 or Alt+E for errors)

+            block

+                integer :: debug_unit

+                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+                write(debug_unit, '(A)') '>>> INSIDE F8/ALT-E HANDLER <<<'

+                write(debug_unit, '(A)') 'Calling toggle_diagnostics_panel...'

+                close(debug_unit)

+            end block

+            block

+                integer :: debug_unit

+                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+                write(debug_unit, '(A)') 'toggle_diagnostics_panel returned'

+                close(debug_unit)

+            end block

+            ! DEBUG: Show unhandled function keys

+            if (index(key_str, 'f') == 1 .or. index(key_str, 'shift-f') == 1) then

+                call terminal_move_cursor(editor%screen_rows, 1)

+                call terminal_write('[DEBUG] Unhandled key: ' // trim(key_str) // '                ')

+            end if

+

+    ! ==================================================

+    ! LSP Definition Response Handler

+    ! ==================================================

+

+    ! Wrapper callback for go to definition

+    subroutine handle_definition_response_wrapper(request_id, response)

+        use lsp_protocol_module, only: lsp_message_t

+        integer, intent(in) :: request_id

+        type(lsp_message_t), intent(in) :: response

+

+        ! Call actual handler with saved editor state

+        if (allocated(saved_editor_for_callback)) then

+            call handle_definition_response_impl(saved_editor_for_callback, response)

+        end if

+    end subroutine handle_definition_response_wrapper

+

+    ! Handle LSP textDocument/definition response

+    subroutine handle_definition_response_impl(editor, response)

+        use lsp_protocol_module, only: lsp_message_t

+        use json_module, only: json_value_t, json_get_object, json_get_string, &

+                               json_get_number, json_array_size, json_get_array_element, &

+                               json_has_key

+        type(editor_state_t), intent(inout) :: editor

+        type(lsp_message_t), intent(in) :: response

+        type(json_value_t) :: location_obj, range_obj, start_obj

+        character(len=:), allocatable :: uri, filepath

+        real(8) :: line_real, col_real

+        integer :: target_line, target_col, i, num_locations

+        logical :: found_file

+

+        ! Log response for debugging

+        block

+            integer :: debug_unit

+            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+            write(debug_unit, '(A)') '>>> DEFINITION RESPONSE RECEIVED <<<'

+            close(debug_unit)

+        end block

+

+        ! Try to treat result as array first

+        num_locations = json_array_size(response%result)

+

+        if (num_locations > 0) then

+            ! Array of locations - take first one

+            location_obj = json_get_array_element(response%result, 0)

+        else if (json_has_key(response%result, "uri")) then

+            ! Single location object

+            location_obj = response%result

+        else

+            ! No definition found

+            call terminal_move_cursor(editor%screen_rows, 1)

+            call terminal_write('No definition found                           ')

+            return

+        end if

+

+        ! Extract URI

+        uri = json_get_string(location_obj, 'uri', '')

+        if (len(uri) == 0) then

+            call terminal_move_cursor(editor%screen_rows, 1)

+            call terminal_write('Invalid definition response                   ')

+            return

+        end if

+

+        ! Convert URI to filepath (remove file:// prefix)

+        if (len(uri) > 7 .and. uri(1:7) == 'file://') then

+            filepath = uri(8:)

+        else

+            filepath = uri

+        end if

+

+        ! Get range

+        range_obj = json_get_object(location_obj, 'range')

+        start_obj = json_get_object(range_obj, 'start')

+

+        line_real = json_get_number(start_obj, 'line', 0.0d0)

+        col_real = json_get_number(start_obj, 'character', 0.0d0)

+

+        ! Convert from 0-based LSP to 1-based editor coordinates

+        target_line = int(line_real) + 1

+        target_col = int(col_real) + 1

+

+        ! Log details

+        block

+            integer :: debug_unit

+            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')

+            write(debug_unit, '(A)') 'File: ' // trim(filepath)

+            write(debug_unit, '(A,I0,A,I0)') 'Position: line=', target_line, ', col=', target_col

+            close(debug_unit)

+        end block

+

+        ! Check if the file is already open in a tab

+        found_file = .false.

+        do i = 1, size(editor%tabs)

+            if (allocated(editor%tabs(i)%filename)) then

+                if (trim(editor%tabs(i)%filename) == trim(filepath)) then

+                    ! Switch to this tab

+                    editor%active_tab_index = i

+                    found_file = .true.

+                    exit

+                end if

+            end if

+        end do

+

+        ! If file not found in tabs, report location

+        if (.not. found_file) then

+            call terminal_move_cursor(editor%screen_rows, 1)

+            call terminal_write('Found in: ' // trim(filepath) // '                ')

+            return

+        end if

+

+        ! Jump to the line and column in current tab

+        editor%cursors(editor%active_cursor)%line = target_line

+        editor%cursors(editor%active_cursor)%column = target_col

+

+        ! Center viewport on target

+        editor%viewport_line = max(1, target_line - editor%screen_rows / 2)

+

+        call terminal_move_cursor(editor%screen_rows, 1)

+        call terminal_write('Jumped to definition                          ')

+    end subroutine handle_definition_response_impl

+

+    subroutine send_request(manager, server_index, msg, callback)

+        type(lsp_manager_t), intent(inout) :: manager

+        integer, intent(in) :: server_index

+        if (server_index < 1 .or. server_index > manager%num_servers) return

+        if (.not. manager%servers(server_index)%initialized .and. &

+            .not. manager%servers(server_index)%initializing) return

+        call send_raw_message(manager%servers(server_index), json_msg)

+        call track_request(manager%servers(server_index), msg%id)

+            call register_callback(manager, msg%id, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+        call send_request(manager, server_index, msg, callback)

+    character(len=*), parameter :: COLOR_KEYWORD = char(27) // '[1;34m'     ! Bold Blue

+    character(len=*), parameter :: COLOR_STRING = char(27) // '[32m'        ! Green

+    character(len=*), parameter :: COLOR_NUMBER = char(27) // '[35m'        ! Magenta

+    character(len=*), parameter :: COLOR_COMMENT = char(27) // '[90m'       ! Gray

+    character(len=*), parameter :: COLOR_OPERATOR = char(27) // '[33m'      ! Yellow

+    character(len=*), parameter :: COLOR_TYPE = char(27) // '[36m'          ! Cyan

+    character(len=*), parameter :: COLOR_FUNCTION = char(27) // '[1;36m'    ! Bold Cyan

+    character(len=*), parameter :: COLOR_PREPROC = char(27) // '[95m'       ! Light Magenta

+    character(len=*), parameter :: COLOR_RESET = char(27) // '[0m'

+                        ! Function keys F1-F8: ESC [ 1 X ~ or ESC [ 1 X ; modifier ~

+                        if (char_code >= 0) then

+                            ch = achar(char_code)

+                            if (ch == '~') then

+                                ! Unmodified F1-F8

+                                select case(ch3)

+                                case('1')

+                                    key_str = 'f1'

+                                case('2')

+                                    key_str = 'f2'

+                                case('3')

+                                    key_str = 'f3'

+                                case('4')

+                                    key_str = 'f4'

+                                case('5')

+                                    key_str = 'f5'

+                                case('7')

+                                    key_str = 'f6'

+                                case('8')

+                                    key_str = 'f7'

+                                case('9')

+                                    key_str = 'f8'

+                                end select

+                            else if (ch == ';') then

+                                ! Modified F1-F8: ESC [ 1 X ; modifier ~

+                                call handle_modified_function_key(key_str, '1', ch3)

+                            end if

+                        ! Function keys F9-F12: ESC [ 2 X ~ or ESC [ 2 X ; modifier ~

+                        if (char_code >= 0) then

+                            ch = achar(char_code)

+                            if (ch == '~') then

+                                ! Unmodified F9-F12

+                                select case(ch3)

+                                case('0')

+                                    key_str = 'f9'

+                                case('1')

+                                    key_str = 'f10'

+                                case('3')

+                                    key_str = 'f11'

+                                case('4')

+                                    key_str = 'f12'

+                                end select

+                            else if (ch == ';') then

+                                ! Modified F9-F12: ESC [ 2 X ; modifier ~

+                                call handle_modified_function_key(key_str, '2', ch3)

+                            end if

+    subroutine handle_modified_function_key(key_str, series, fkey_code)

+        character(len=*), intent(out) :: key_str

+        character, intent(in) :: series      ! '1' for ESC[1X~, '2' for ESC[2X~

+        character, intent(in) :: fkey_code   ! The X in ESC[1X~ or ESC[2X~

+        character :: ch, modifier_ch

+        integer :: char_code, modifier

+        character(len=10) :: base_key

+

+        key_str = ''

+

+        ! Determine base function key from series and code

+        if (series == '1') then

+            ! ESC[1X~ format: 1=F1, 2=F2, 3=F3, 4=F4, 5=F5, 7=F6, 8=F7, 9=F8

+            select case(fkey_code)

+            case('1')

+                base_key = 'f1'

+            case('2')

+                base_key = 'f2'

+            case('3')

+                base_key = 'f3'

+            case('4')

+                base_key = 'f4'

+            case('5')

+                base_key = 'f5'

+            case('7')

+                base_key = 'f6'

+            case('8')

+                base_key = 'f7'

+            case('9')

+                base_key = 'f8'

+            case default

+                return

+            end select

+        else if (series == '2') then

+            ! ESC[2X~ format: 0=F9, 1=F10, 3=F11, 4=F12

+            select case(fkey_code)

+            case('0')

+                base_key = 'f9'

+            case('1')

+                base_key = 'f10'

+            case('3')

+                base_key = 'f11'

+            case('4')

+                base_key = 'f12'

+            case default

+                return

+            end select

+        else

+            return

+        end if

+

+        ! Read modifier (should be a digit 2-8)

+        char_code = terminal_read_char()

+        if (char_code < 0) return

+        modifier_ch = achar(char_code)

+

+        ! Read terminating ~

+        char_code = terminal_read_char()

+        if (char_code < 0 .or. achar(char_code) /= '~') return

+

+        ! Parse modifier: 2=Shift, 3=Alt, 4=Alt+Shift, 5=Ctrl, 6=Ctrl+Shift, 7=Alt+Ctrl, 8=Alt+Shift

+        read(modifier_ch, '(i1)') modifier

+

+        select case(modifier)

+        case(2)  ! Shift

+            key_str = 'shift-' // trim(base_key)

+        case(3)  ! Alt

+            key_str = 'alt-' // trim(base_key)

+        case(4)  ! Alt+Shift

+            key_str = 'alt-shift-' // trim(base_key)

+        case(5)  ! Ctrl

+            key_str = 'ctrl-' // trim(base_key)

+        case(6)  ! Ctrl+Shift

+            key_str = 'ctrl-shift-' // trim(base_key)

+        case(7)  ! Alt+Ctrl

+            key_str = 'alt-ctrl-' // trim(base_key)

+        case(8)  ! Alt+Ctrl+Shift

+            key_str = 'alt-ctrl-shift-' // trim(base_key)

+        case default

+            ! Unknown modifier, return unmodified key

+            key_str = trim(base_key)

+        end select

+    end subroutine handle_modified_function_key

+

+        lines(i) = "  F2                  rename symbol"; i = i + 1

+        lines(i) = "  F4                  document symbols (outline)"; i = i + 1

+        lines(i) = "  F6                  workspace symbols (search project)"; i = i + 1

+        lines(i) = "  F8                  toggle diagnostics panel (errors)"; i = i + 1

+        lines(i) = "  ctrl-p              command palette"; i = i + 1

+#!/bin/bash

+# Test what escape sequences the terminal sends for function keys

+

+echo "Press keys to see their escape sequences (Ctrl+C to quit):"

+echo "Try: F12, Shift-F12, F8, F4, F6, F2"

+echo ""

+

+# Read raw input and show escape sequences

+while true; do

+    read -rsn1 char

+    if [[ $char == $'\e' ]]; then

+        # Start of escape sequence

+        seq="$char"

+        # Read the rest quickly

+        while read -rsn1 -t 0.001 char; do

+            seq="$seq$char"

+        done

+        # Show it in a readable format

+        echo -n "Escape sequence: "

+        echo -n "$seq" | od -An -tx1 | tr -d ' \n'

+        echo " (raw: $(echo -n "$seq" | cat -v))"

+    else

+        echo "Character: '$char' (ASCII: $(printf '%d' "'$char"))"

+    fi

+done

+#!/bin/bash

+# Test what escape sequences WezTerm actually sends for F-keys

+# Press F8, F12, Shift-F12, etc. and see what comes through

+

+echo "=== Raw Key Sequence Tester ==="

+echo "Press F8, F12, or Shift-F12, then Ctrl+C to exit"

+echo "This will show the EXACT escape sequences received"

+echo ""

+

+# Use od to show the raw bytes of each key press

+while true; do

+    echo -n "Press a key: "

+    # Read one key sequence with timeout

+    IFS= read -rsn1 char

+

+    # If it's ESC, read the rest of the sequence

+    if [ "$char" = $'\x1b' ]; then

+        # Read the next character(s) quickly

+        rest=""

+        while IFS= read -rsn1 -t 0.01 c; do

+            rest="$rest$c"

+        done

+        full="$char$rest"

+

+        # Show as hex and as escaped string

+        echo -n "$full" | od -An -tx1 | tr -d ' \n'

+        echo -n " = ESC"

+        echo "$rest" | sed 's/./[&]/g'

+    else

+        echo "$char"

+    fi

+done

+# LSP Feature Test Files

+

+These files are designed to test all LSP features in `fac`. Each file contains intentional errors and cross-references for comprehensive testing.

+

+## Files Overview

+

+### Python Files

+- **calculator.py** - Math functions with intentional errors

+  - Undefined variable errors (`reslt` instead of `result`)

+  - Missing import errors (`math` module)

+  - Multiple functions for testing navigation

+

+- **main.py** - Main program importing calculator

+  - Cross-file references for testing F12

+  - Class structure for Document Symbols

+  - Missing import error (`divide` function)

+

+### Fortran Files

+- **math_utils.f90** - Math utilities module

+  - Vector operations (add, dot product, magnitude)

+  - Matrix multiplication

+  - Intentional errors (uninitialized variables)

+

+- **test_program.f90** - Program using math_utils

+  - Cross-file references to test F12

+  - Undefined variable error

+

+### C Files

+- **utils.c** - Utility functions

+  - Factorial, fibonacci, array operations

+  - Intentional errors (undefined variables, type mismatches)

+

+- **main.c** - Main program using utils

+  - Cross-file function calls

+  - Structure definition

+  - Multiple intentional errors

+

+## Testing LSP Features

+

+### 1. Diagnostics (F8)

+

+**Test:** Open any file and check for error markers in the gutter.

+

+Expected errors:

+- **calculator.py**: `reslt` undefined, `math` not imported

+- **main.py**: `divide` not imported

+- **math_utils.f90**: `undefined_var` in `broken_routine`

+- **test_program.f90**: `undefined_result` not declared

+- **utils.c**: `undefined_var`, type mismatch, missing return

+- **main.c**: `undefined_function`, type mismatch, `undeclared_var`

+

+**How to test:**

+```bash

+fac calculator.py

+# Press F8 to open diagnostics panel

+# Navigate with j/k or ↑/↓

+# Press Enter to jump to error

+```

+

+### 2. Go to Definition (F12)

+

+**Test:** Cross-file navigation between importing files.

+

+**In main.py:**

+1. Put cursor on `add` on line ~15

+2. Press `F12`

+3. Should jump to `def add()` in calculator.py

+

+**In test_program.f90:**

+1. Put cursor on `vector_add` on line ~23

+2. Press `F12`

+3. Should jump to `subroutine vector_add` in math_utils.f90

+

+**In main.c:**

+1. Put cursor on `factorial` on line ~28

+2. Press `F12`

+3. Should jump to `int factorial()` in utils.c

+

+**Return:** Press `Alt+,` to jump back!

+

+### 3. Find References (Shift+F12)

+

+**Test:** Find all usages of a function.

+

+**In calculator.py:**

+1. Put cursor on `calculate_total` function name

+2. Press `Shift+F12`

+3. Should show:

+   - Definition in calculator.py

+   - Usage in main.py (imported and called)

+

+**In math_utils.f90:**

+1. Put cursor on `vector_dot`

+2. Press `Shift+F12`

+3. Should show usage in test_program.f90

+

+### 4. Code Actions (Ctrl+.)

+

+**Test:** Quick fixes for errors.

+

+**In calculator.py line ~48:**

+1. Put cursor on `reslt` (undefined error)

+2. Press `Ctrl+.`

+3. Should offer to fix the typo or define `reslt`

+

+**In main.py line ~45:**

+1. Put cursor on `divide` (not imported error)

+2. Press `Ctrl+.`

+3. Should offer to add `divide` to imports

+

+### 5. Rename Symbol (F2)

+

+**Test:** Rename across files.

+

+**In calculator.py:**

+1. Put cursor on `add` function name

+2. Press `F2`

+3. Type new name (e.g., `add_numbers`)

+4. Press Enter

+5. Check:

+   - Function renamed in calculator.py

+   - Import statement updated in main.py

+   - Function call updated in main.py

+

+**Undo:** Press `Ctrl+Z` repeatedly to revert

+

+### 6. Document Symbols (F4)

+

+**Test:** See file outline.

+

+**In calculator.py:**

+1. Press `F4`

+2. Should see:

+   - `add` function

+   - `subtract` function

+   - `multiply` function

+   - `divide` function

+   - etc.

+3. Type "broken" to filter

+4. Press Enter to jump to function

+

+**In main.py:**

+1. Press `F4`

+2. Should see:

+   - `DataProcessor` class

+   - `process_data` function

+   - `main` function

+

+### 7. Workspace Symbols (F6)

+

+**Test:** Search symbols across ALL files.

+

+1. Press `F6`

+2. Type "add"

+3. Should see:

+   - `add` function in calculator.py

+   - `vector_add` in math_utils.f90

+   - Maybe `sum_array` in utils.c (fuzzy match)

+4. Navigate with j/k

+5. Press Enter to jump (opens file if needed)

+

+**Try different searches:**

+- "calc" → finds `calculate_total`, `calculator`, etc.

+- "vector" → finds all vector functions

+- "fact" → finds `factorial`

+

+### 8. Signature Help

+

+**Test:** Parameter hints while typing.

+

+**In any Python file:**

+1. Type: `calculate_total(`

+2. Should see tooltip: `calculate_total(items)`

+3. As you type, current parameter is highlighted

+

+**In Fortran:**

+1. Type: `call vector_add(`

+2. Should see signature with parameters

+

+### 9. Document Formatting (Shift+Alt+F)

+

+**Test:** Auto-format code.

+

+**In calculator.py:**

+1. Mess up the formatting (add extra spaces, wrong indentation)

+2. Press `Shift+Alt+F`

+3. Code should be auto-formatted to PEP 8 style

+

+**In utils.c:**

+1. Mess up braces and indentation

+2. Press `Shift+Alt+F`

+3. Code should be formatted with clang-format

+

+### 10. Command Palette (Ctrl+P)

+

+**Test:** Access commands without keybindings.

+

+1. Press `Ctrl+P`

+2. Type "format"

+3. Select "Format Document"

+4. Same as Shift+Alt+F

+

+Or:

+1. Press `Ctrl+P`

+2. Type "def"

+3. Select "Go to Definition"

+4. Same as F12

+

+## Language Server Setup

+

+To test these files, you need language servers installed:

+

+**Python:**

+```bash

+pip install python-lsp-server

+```

+

+**Fortran:**

+```bash

+pip install fortls

+```

+

+**C/C++:**

+```bash

+# macOS

+brew install llvm

+

+# Linux

+sudo apt install clangd

+```

+

+## Expected Behavior

+

+### With Language Server Installed:

+- ✅ Red/yellow error markers in gutter

+- ✅ F12 jumps to definitions (even across files)

+- ✅ Shift+F12 shows all references

+- ✅ Ctrl+. offers quick fixes

+- ✅ F2 renames across files

+- ✅ F4 shows file outline

+- ✅ F6 searches all symbols

+- ✅ Shift+Alt+F formats code

+

+### Without Language Server:

+- ❌ No error markers

+- ❌ LSP features won't work

+- ✅ Basic editing still works

+- ✅ Syntax highlighting may work (if implemented separately)

+

+## Known Issues to Test

+

+1. **Syntax highlighting for Fortran** - Check if keywords are colored

+2. **F8 vs Ctrl+D** - Check if modifier keys work correctly

+3. **Cross-file tabs** - Check if F12 opens new tabs correctly

+4. **Jump stack** - Check if Alt+, returns to previous location

+

+## Quick Test Checklist

+

+- [ ] Open calculator.py and see diagnostics (red/yellow markers)

+- [ ] Press F8 and see error list

+- [ ] F12 on `add` in main.py → jumps to calculator.py

+- [ ] Alt+, → jumps back

+- [ ] Shift+F12 on `calculate_total` → shows references

+- [ ] F2 on `multiply` → rename and see it update in both files

+- [ ] F4 → see file outline

+- [ ] F6, type "vector" → find Fortran functions

+- [ ] Ctrl+. on an error → see quick fixes

+- [ ] Shift+Alt+F → format code

+"""

+Simple calculator module for testing LSP features.

+

+Test these features:

+- Diagnostics: See the intentional errors below

+- Go to Definition: F12 on function calls

+- Find References: Shift+F12 on function names

+- Rename: F2 on any function/variable

+- Code Actions: Ctrl+. on errors

+- Document Symbols: Ctrl+Shift+O to see outline

+- Formatting: Shift+Alt+F to format

+"""

+

+def add(x, y):

+    """Add two numbers together."""

+    return x + y

+

+

+def subtract(x, y):

+    """Subtract y from x."""

+    return x - y

+

+

+def multiply(x, y):

+    """Multiply two numbers."""

+    return x * y

+

+

+def divide(x, y):

+    """Divide x by y."""

+    if y == 0:

+        raise ValueError("Cannot divide by zero")

+    return x / y

+

+

+def calculate_total(items):

+    """Calculate total from a list of numbers."""

+    total = 0

+    for item in items:

+        total = total + item

+    return total

+

+

+# Intentional error for diagnostics testing

+def broken_function():

+    """This function has an error - undefined variable."""

+    result = add(5, 3)

+    print(f"Result: {reslt}")  # ERROR: typo - should be 'result'

+    return reslt

+

+

+# Another intentional error - missing import

+def use_math():

+    """Uses math module without importing it."""

+    return math.sqrt(16)  # ERROR: 'math' is not defined

+

+

+# Test code

+if __name__ == "__main__":

+    # These work fine

+    print(add(10, 5))

+    print(subtract(10, 5))

+    print(multiply(10, 5))

+    print(divide(10, 5))

+

+    # This will show diagnostic errors

+    broken_function()

+    use_math()

+/*

+ * Main program using utility functions

+ *

+ * Test cross-file navigation:

+ * - F12 on 'factorial' should jump to utils.c

+ * - Shift+F12 on 'fibonacci' should show all usages

+ * - Ctrl+Shift+T and search "sum" to find sum_array

+ */

+

+#include <stdio.h>

+

+// Forward declarations from utils.c

+int factorial(int n);

+int fibonacci(int n);

+int sum_array(int *arr, int size);

+int find_max(int *arr, int size);

+

+// Structure for testing Document Symbols (Ctrl+Shift+O)

+typedef struct {

+    int id;

+    char name[50];

+    double value;

+} Record;

+

+// Test: F12 on this function name to jump to definition

+void process_records(Record *records, int count) {

+    printf("Processing %d records\n", count);

+    for (int i = 0; i < count; i++) {

+        printf("Record %d: %s = %.2f\n",

+               records[i].id,

+               records[i].name,

+               records[i].value);

+    }

+}

+

+int main() {

+    printf("Testing LSP features in C\n\n");

+

+    // Test factorial

+    // F12 on 'factorial' should jump to utils.c

+    int fact = factorial(5);

+    printf("factorial(5) = %d\n", fact);

+

+    // Test fibonacci

+    // Shift+F12 on 'fibonacci' should show all usages

+    int fib = fibonacci(7);

+    printf("fibonacci(7) = %d\n", fib);

+

+    // Test array functions

+    int numbers[] = {5, 2, 8, 1, 9, 3};

+    int size = sizeof(numbers) / sizeof(numbers[0]);

+

+    // F12 on 'sum_array' should jump to definition

+    int total = sum_array(numbers, size);

+    printf("sum_array() = %d\n", total);

+

+    // F12 on 'find_max' should jump to definition

+    int max = find_max(numbers, size);

+    printf("find_max() = %d\n", max);

+

+    // Test with records

+    Record records[2] = {

+        {1, "Alpha", 3.14},

+        {2, "Beta", 2.71}

+    };

+    process_records(records, 2);

+

+    // Intentional errors for diagnostics

+    // ERROR: undefined function

+    int result = undefined_function(10);

+

+    // ERROR: type mismatch

+    char *str = fact;

+

+    // ERROR: undeclared variable

+    printf("Value: %d\n", undeclared_var);

+

+    return 0;

+}

+"""

+Main module that uses calculator.

+

+Test cross-file navigation:

+- Put cursor on 'add' below and press F12 - should jump to calculator.py

+- Put cursor on 'calculate_total' and press Shift+F12 - find all usages

+- Use Ctrl+Shift+T and search for "multiply" - should find it in calculator.py

+"""

+

+from calculator import add, subtract, multiply, calculate_total

+

+

+def process_data(numbers):

+    """Process a list of numbers using calculator functions."""

+    # Test: F12 on 'add' should jump to calculator.py

+    sum_result = add(numbers[0], numbers[1])

+

+    # Test: F12 on 'multiply' should jump to calculator.py

+    product = multiply(sum_result, 2)

+

+    # Test: Shift+F12 on 'calculate_total' should show usages

+    total = calculate_total(numbers)

+

+    return {

+        'sum': sum_result,

+        'product': product,

+        'total': total

+    }

+

+

+class DataProcessor:

+    """A class for processing numerical data.

+

+    Test Document Symbols (Ctrl+Shift+O) to see this class structure.

+    """

+

+    def __init__(self, data):

+        self.data = data

+        self.processed = False

+

+    def calculate_sum(self):

+        """Calculate sum using calculator module."""

+        return calculate_total(self.data)

+

+    def calculate_average(self):

+        """Calculate average of the data."""

+        total = self.calculate_sum()

+        return divide(total, len(self.data))  # ERROR: 'divide' not imported

+

+    def process(self):

+        """Process the data."""

+        self.processed = True

+        return self.calculate_average()

+

+

+# Test with intentional error

+def main():

+    numbers = [1, 2, 3, 4, 5]

+

+    # This works

+    result = process_data(numbers)

+    print(f"Results: {result}")

+

+    # This has errors

+    processor = DataProcessor(numbers)

+    avg = processor.process()  # Will error due to missing 'divide' import

+    print(f"Average: {avg}")

+

+

+if __name__ == "__main__":

+    main()

+module math_utils

+    ! Simple math utilities for testing LSP features

+    !

+    ! Test:

+    ! - Syntax highlighting (keywords, comments, strings)

+    ! - Go to Definition (F12 on subroutine calls)

+    ! - Find References (Shift+F12 on subroutine names)

+    ! - Document Symbols (Ctrl+Shift+O to see module structure)

+    ! - Formatting (Shift+Alt+F)

+

+    implicit none

+    private

+

+    public :: vector_add, vector_dot, vector_magnitude

+    public :: matrix_multiply

+

+contains

+

+    subroutine vector_add(a, b, result, n)

+        ! Add two vectors element-wise

+        integer, intent(in) :: n

+        real, intent(in) :: a(n), b(n)

+        real, intent(out) :: result(n)

+        integer :: i

+

+        do i = 1, n

+            result(i) = a(i) + b(i)

+        end do

+    end subroutine vector_add

+

+    function vector_dot(a, b, n) result(dot_product)

+        ! Calculate dot product of two vectors

+        integer, intent(in) :: n

+        real, intent(in) :: a(n), b(n)

+        real :: dot_product

+        integer :: i

+

+        dot_product = 0.0

+        do i = 1, n

+            dot_product = dot_product + a(i) * b(i)

+        end do

+    end function vector_dot

+

+    function vector_magnitude(vec, n) result(magnitude)

+        ! Calculate magnitude of a vector

+        integer, intent(in) :: n

+        real, intent(in) :: vec(n)

+        real :: magnitude

+        integer :: i

+        real :: sum_squares

+

+        sum_squares = 0.0

+        do i = 1, n

+            sum_squares = sum_squares + vec(i)**2

+        end do

+        magnitude = sqrt(sum_squares)

+    end function vector_magnitude

+

+    subroutine matrix_multiply(A, B, C, m, n, p)

+        ! Multiply two matrices: C = A * B

+        ! A is m x n, B is n x p, C is m x p

+        integer, intent(in) :: m, n, p

+        real, intent(in) :: A(m, n), B(n, p)

+        real, intent(out) :: C(m, p)

+        integer :: i, j, k

+

+        ! Intentional error: missing initialization

+        do i = 1, m

+            do j = 1, p

+                ! ERROR: C(i,j) not initialized before use

+                do k = 1, n

+                    C(i, j) = C(i, j) + A(i, k) * B(k, j)

+                end do

+            end do

+        end do

+    end subroutine matrix_multiply

+

+    ! Intentional error function for diagnostics

+    subroutine broken_routine(x, y)

+        real, intent(in) :: x

+        real, intent(out) :: y

+        real :: temp

+

+        temp = x * 2.0

+        ! ERROR: using undefined variable

+        y = temp + undefined_var

+    end subroutine broken_routine

+

+end module math_utils

+program test_program

+    ! Test program using math_utils module

+    !

+    ! Test cross-file navigation:

+    ! - F12 on 'vector_add' should jump to math_utils.f90

+    ! - Shift+F12 on 'vector_dot' should show all usages

+    ! - Ctrl+Shift+T and search "vector" to find all vector functions

+

+    use math_utils

+    implicit none

+

+    integer, parameter :: n = 3

+    real :: a(n), b(n), result(n)

+    real :: dot_prod, mag

+    integer :: i

+

+    ! Initialize vectors

+    a = [1.0, 2.0, 3.0]

+    b = [4.0, 5.0, 6.0]

+

+    ! Test vector addition

+    ! F12 on vector_add should jump to math_utils.f90

+    call vector_add(a, b, result, n)

+

+    print *, 'Vector A:', a

+    print *, 'Vector B:', b

+    print *, 'A + B   :', result

+

+    ! Test dot product

+    ! F12 on vector_dot should jump to definition

+    dot_prod = vector_dot(a, b, n)

+    print *, 'A · B   :', dot_prod

+