v0.20.1

The language engine is the editor extension's analyzer at 10.7.1

• What a one-line If runs after a colon belongs to the If. After
  If conn Is Nothing Then F = 1: Exit Function, the next line was reported
  as unreachable. A Set x = Nothing or an Erase after the colon no longer
  makes the next line report an unset object or an unallocated array, and an
  object set inside a one-line If is no longer reported as Nothing after it.
• A comment ending in _ runs on to the next line, as it does in the
  VBE. That line is no longer checked as code, so a name on it is not
  reported as undeclared and an End Sub on it does not end the procedure.
• Spaces after a line continuation's _ still continue the line. The
  next line no longer reports a missing Then.
• =>, =<, >< and 1. are no longer reported as code that will not
  compile. The VBE accepts them and writes them as >=, <=, <> and
  1#. The VBE also reads &17 as the octal &O17, so s = "a" &1 does not
  compile, and it is now reported.
• A block If closed with the one-word EndIf is closed. It no longer
  reports a missing End If, and pressing Enter after its If line no
  longer adds a second one.
• Needs, 2 is a call, so a missing required argument is reported there
  too.
• Variables named text or output keep their spelling. The editor
  capitalized them as keywords. Option Compare Text is still capitalized,
  and Err.LastDllError is spelled the way the VBE writes it.
• Shape.Duplicate returns a Shape and SparklineGroup.SeriesColor a
  FormatColor, so assigning them is no longer a type mismatch, and a
  Worksheets or Charts collection can be assigned to a Sheets variable.

Everything in 0.20.0 is here unchanged.

v0.20.0

Opening the editor no longer costs a failed Windows sign-in

Each xlide surface, the editor and the Object Browser palette, was one
failed Windows sign-in, and ten in ten minutes lock a local account.
WebView2 runtimes 152 to 154 call LogonUser with an invalid password as the
current user every time an environment is created. The surfaces now create
theirs with the feature behind it turned off, and the account's bad-password
count stays at 0 through an Excel launch with both open. (#29)

A line that will not compile no longer freezes the Immediate panel

debug.prnt "A" in the Immediate panel left the editor stuck. Debug.Print
printed nothing, Break and Reset did nothing, and closing the editor asked to
stop the debugger. The panel ran its line inside the page's message handler,
and the stop behind the compile error held every later message from the page.

The line runs from the host's own queue now. The compile error's box stays up
for you to answer, as the editor's own Immediate window does, since a box can
as easily be your own MsgBox. Once you answer it, the stop is cleared, the
box's words show in the panel, and the next line prints. (#30)

A line typed at a breakpoint your own line reached evaluates there. Type
Runner.Walk in the panel, stop at a breakpoint inside it, and ? counter
now prints the local's value, as it does in the editor's own Immediate window.
It was refused as "already in progress".

The explorer follows what running code adds and removes

Components that running code adds or removes appear in the tree once the
code stops. The tree used to wait until you typed in an editor. (#28)

A password-protected project no longer freezes the tree. Office's own
Analysis ToolPak VBA add-in is protected, and while it was open the tree
published nothing at all. A locked project is passed over now.

Abort no longer fails on git's lock

Abort, pressed on a conflicted pull, could fail with "Unable to create
index.lock: File exists" and leave the merge standing. It happened when the
Source Control pane's own status refresh was running: git status writes the
index out under that lock. Every git command now runs with
--no-optional-locks, as git's documentation advises for a status run in the
background, so a refresh never holds the lock a write needs.

The editor stays on the module you chose

Closing a pane and then adding a class no longer takes the editor back to
the module before. The page's answer to a tab list could arrive after the
editor had moved on, and it was obeyed. Each list now carries a revision, and
a late answer is left alone.

The attribute findings say what is missing

A procedure with a hidden description and no annotation now reads
"GetChildRows has VB_Description = "..." but no '@description annotation."
A finding for an annotation not yet applied says what the module has now, and
ends "Save to apply it, or use the quick fix."

The language engine is the editor extension's analyzer at 10.6.0

• Comparing a read-only property is no longer reported as assigning to
  it. With Part a Property Get alone, If w.Part = "a" Then and
  Debug.Print w.Part = "a" read as "Cannot assign to read-only property".
  Assigning to it still reports.
• Worksheets.NoSuchMember is reported, as the VBE refuses it.
• A declaration after a procedure closed with the wrong End keyword is
  reported for where it is. End Function closing a Property Get made
  every module-level line after it read as inside the procedure.

Everything in 0.19.0 is here unchanged.

v0.19.0

Worksheet functions are no longer underlined in red

Application.Match, VLookup, Sum, CountA, Index and Transpose
compile and run, and the editor was reporting every one of them as a missing
member. They sit on no interface in Excel's type library at all - Excel
resolves them when the code runs - and the rule was reading the member list
alone.

It reads the type library's own NONEXTENSIBLE flag now. An interface marked
closed can gain no members at run time, so the VBE refuses a name that is not
on it; without the flag VBA compiles the call and asks for the name when it
runs. Four of the thirty-five Excel types with complete member lists are
closed - Worksheet, Chart, Sheets and Workbooks - and those still
report. Application, Range, Workbook, Font and the rest no longer do.

The cost, stated plainly: a typo on an extensible type is now caught when the
code runs rather than while it is written. Me.asdf in a ThisWorkbook module
goes with it. Underlining code that works was the worse of the two.

The missing-reference error carries the fix that ends it

Add a reference to the Word object library now sits on the finding,
ahead of the suppression, because hiding a compile error is a last resort and
one tick in Tools > References is the fix. Choosing it puts the reference on
the project, and the error clears without the module being touched.

The library comes from the finding itself, so what is offered is only ever a
library the product would have named. A project that already has the reference
is not offered it again.

A referenced application's members are labelled with their own
application. In a workbook that references Word, hovering wd.Visible said
"Excel host property", because a model merged from two libraries carries one
host name - the project's own. It says Word now, and completion offers a Word
type as a "Word type".

The language engine is the editor extension's analyzer at 10.4.2.

Everything in 0.18.0 is here unchanged.

v0.18.0

Break mode evaluates in the stopped scope

At a breakpoint the Immediate window now takes a full expression. ? counter + 1, a function call, anything VBA would accept there. 0.13.0
answered a bare name from the Locals window and declined the rest, because
evaluating meant adding a procedure and that resets the project. Break mode no
longer uses one: the line goes to the editor's own hidden Immediate window,
which already holds the paused procedure's scope, and the session stays paused
through it. A run-time or compile error comes back as the text VBA reports -
Run-time error '11': Division by zero - with the pause intact. Design mode
still evaluates by writing a scratch procedure, which is why the two behave
differently at all (#21).

Code that drives another Office application is understood

A workbook that references Word can name Word's types, and the editor now
knows it. Dim wd As Word.Application resolves, wd. offers Word's
members, wd.Documents.Add is checked against Word's model, hover describes
what it finds there, and canonical casing knows Word's spellings. Every
combination of Excel, Word, PowerPoint and Access is covered,
including one application driving another instance of itself.

Until now that code was underlined as an error. The analyzer reports
missing-library-reference on a name from a library the project has no
reference to, which is what the VBE does - it refuses to compile the whole
project and says "User-defined type not defined". This editor never told it
which libraries there were, so every project that automates another
application got that error on code that works. It reads the project's
References now. Late binding is untouched: Dim x As Object with
CreateObject("Word.Application") names nothing from a library and is never
reported.

The references are live rather than read once. Tick a library in the
References dialog and the findings move with it, without the module being
touched.

A broken reference is left out of what the analyzer is told, because the
compiler cannot use one either. The project route on the api lists a
project's references with their names, identities and broken flags, from the
same read the analyzer is given, so the two cases can be told apart.

The language engine is the editor extension's analyzer at 10.4.1.

Everything in 0.17.0 is here unchanged.

v0.17.0

Code that is doing nothing says so

Four rules point at code a module does not need, and the editor fades it
rather than underlining it. unused-variable for a local or a module-level
Private nothing names, variable-never-read for one whose every mention
assigns to it, unused-procedure for a Private Sub, Function or Property
nothing in its module calls, and unreachable-code for statements after an
Exit Sub, a GoTo or an End in the same block. They report as
information, so they sit under Messages in the Problems pane and never stand
in front of a real error.

A Public procedure is never reported: a button, a shape, the ribbon, a hotkey
or Application.Run in another file can call one and none of that is visible
from here. Event handlers, interface members, Auto_Open and anything
carrying an attribute are left alone too, and every string literal in the
project is searched before a Private procedure is called unused. A For
counter, an array written by element, a ReDim Preserve target and a variable
passed to a procedure all count as reads.

An information finding is no longer drawn as an error. The analyzer calls
its third severity information and the editor's marker table knew only
info, so anything wearing that word fell through to the most alarming
reading it had: a red squiggle, on valid code. It has been doing that to
event-handler-module-scope since that rule arrived. Translated once now,
where findings reach the page, and an unknown severity is drawn as information
rather than as an error.

Six rules read ''' doc comments. doc-param-missing and
doc-param-unknown for parameters the comment does not describe or describes
and the procedure does not have, doc-returns-missing and
doc-returns-unexpected for a return that is not documented or documented on
a Sub, and doc-tag-duplicate and doc-tag-unclosed for the tags themselves.
They report as warnings.

The problems route answers a tag on each finding, unnecessary on the
ranges the editor fades, so a tool listing findings can draw them the way the
editor does.

The language engine is the editor extension's analyzer at 9.0.0, where 0.16.2
carried 8.2.1.

Everything in 0.16.2 is here unchanged.

v0.16.2

The Option Explicit fix writes what it says

Add Option Explicit no longer lands as Option Explicit(). The fix
inserted its statement correctly, and a formatting pass running behind it
answered from a copy of the line taken before the insert - so its answer
arrived as brackets on the end of the new text, and where the module's first
line was a procedure header, the header went with it. That pass waits for
the edit now, and it refuses to answer about text the host does not hold.
Reported as #25 and #27.

A malformed Option line reports as an error. Option Explicit() passed
analysis while the compiler refused it, which is what let the write above go
unnoticed as far as it did.

The statement leaves a blank line under itself. A module whose first
line is already blank keeps the one it has.

A dialog taller than the window scrolls inside itself. Nine of the
sixteen cards had no height ceiling at all, so a short window or a high zoom
put their buttons off the bottom of the screen with no way to reach them.
Each stops at what its own backdrop leaves it now and scrolls past that,
with the same scrollbar the panes use. Reported as #26.

A dialog's heading strip stays put while its rows scroll under it. The
title and the X sit on the card's top edge wherever the content has got to.

The Settings dialog lists only what it alone sets. The Explorer's layout
and the form designer's snapping had rows there as well as controls where
they are used; both rows are gone, the footer under them with them, and so
is the dead space a hidden tooltip was holding at the bottom of the card.

In Word, the Immediate window, test runs and the dirty check reach the
host. All three could report "The host application could not be reached"
for a whole session. The lookup that finds Word's own automation object took
the first document pane it saw; of the windows a Word session offers, one
answers and the rest refuse, and which came first was a matter of window
order. Every candidate is asked now, and the first that answers is the one
used.

A save no longer closes a menu you have just opened. Saving republishes
the project, which re-activated the tab already on screen, and a context
menu standing over the designer went with it.

The api names the containing document a project everywhere a caller meets
one, and keeps file for a real path on disk: the close gesture is now
file with action=close, and the harness client's --workbook switch is
--project.

Everything in 0.16.1 is here unchanged.

v0.16.1

The lightbulb offers only what it can do

The lightbulb asks before it offers. Its refactorings were chosen by the
shape of the text under the caret, and a planner refused only after its
entry was picked: the bulb lit on End Function to offer inlining the
keyword. Each candidate is now put to its own planner first, and the bulb
shows only the ones that would go through. The right-click menu still lists
every refactoring and answers a refusal in words.

It stays cheap on a large module. The question is one round trip per
caret move and answers in under a millisecond once warm, at any module
size. The first question after an edit takes about 85ms on a local in a
14,000-line module.

The Immediate window and the test runner remove their scratch modules
under the pane-tracker hold. Every other removal has been held since
0.15.1, because the editor pumps messages inside a remove, and the tracker
reading an editor mid-change is an access violation in VBE7. These two were
the last left bare.

The Source Control pane's Use button shortens its folder from the
middle. A deep folder stretched the button across the pane. It now reads
Use f:\github\...\fixtures\scmfixture, and its tooltip keeps the whole
path.

A resize no longer logs an uncaught error. The scrolling strips measured
their edges inside their own resize observer, which the browser reports as
a loop. They measure on the next frame.

The state route answers paletteIcon, whether the Object Browser
palette's window carries an icon.

Everything in 0.16.0 is here unchanged.

v0.16.0

Source Control: undo, branches, remotes, and a pull that imports

Undo on the branch head. The head's row in the history carries Undo:
the head goes back one commit, its changes return to the rows, and its
message returns to the box to be edited and committed again. When the head
cannot be undone the button is greyed with the reason - the first commit, a
merge, a commit the upstream already holds, or one that did not touch this
folder.

New branch..., and the remote's branches. The branch select ends in New
branch..., which cuts a branch from the head without importing anything, so
a dirty workbook is no bar. After a fetch, the branches only the remote has
are listed under its name, and picking one makes a local branch of that
name that tracks it. Initialize names the first branch main.

Pull imports what it brings. Pull ran git and left the pulled changes
in the folder, where the next save's export wrote the project's older text
back over them. It has a checkout's shape now: refused while the workbook
is dirty, then the merge, then the import into every open project the
repository holds. A pull that stops on a conflict shows the conflicted
state, with Abort.

The pane's divider drags. The divider between the rows and the
comparison drags, takes the arrow keys, and keeps its width across reloads.
A refresh of the pane is 121ms of git where it was 305, and the branch
select acts on a pick, never on a key walked past.

A write that is two edits far apart is two windows. A rename, a
declaration with its use, or a replace-all cost 1.3s on an 11,000-line
module and 30s at VBA's ceiling, because anything that was not one edit
replaced the module whole. Such a write is now the windows between its
anchors, written in place: 77ms and 513ms for the same edits. A window may
hold 5,000 lines, and a text past the 65,534 lines VBA holds in one module
is refused with the count rather than handed to an editor that faults on
it.

Access saves, and reads dirty. Source control's save and dirty checks
walked Excel's Workbooks, which Access does not have: an Access project
never read as dirty, a checkout could import over an unsaved edit, and a
commit never saved the database. Where a host has no document collection
the project's own Saved flag answers and the editor's Save saves.

Word is proven, and it was renaming its project after every save. A
Word VBA project names Word's save-time temp file - ~WRL0001.tmp - as its
own after a save, and a different one after the next, and this product read
it raw: the tree renamed the project, the analysis started over under a
path with no file behind it, the source control folder was forgotten, and
the document could not be addressed by its name. One reader resolves it
now. Word has a fixture and a suite in the gate beside Access's, and its
launcher gives the fixture a process of its own when your Word is up.

The scm route says the new words - undo, branch and pull - and its
status carries head, undoBlocked and upstreamGone.

Everything in 0.15.1 is here unchanged.

v0.15.1

Two fixes the live gate found after 0.15.0

Applying attributes no longer takes Excel down. Applying a module's
annotations exports the module, removes it and imports the file, and the
editor pumps messages while it does. The pane tracker's window hook ran in
that gap and read the panes and the component list out of an editor that was
mid-change; on a machine with the September Windows update, that was an access
violation inside VBE7.DLL every time. The tracker is held while xlide itself
removes or imports a component - attributes, a sync import, a checkout, the
tree's remove - and catches up once afterwards. The same hold covers the
sync dialog's import and the Source Control pane's Import and checkout.

An undo after a refactor undoes the refactor alone. Text the host writes
into a module - a refactor's members, a rename's result, a module's text
after a write through the api - is its own undo step now. It used to join the
step before it, so one Ctrl+Z after Implement Interface could take a class
back past its Implements line, and in a module the host had first published
empty, back to nothing.

Everything in 0.15.0 is here unchanged: the Source Control pane, the remote
attached from it, the scm route, and the harness that stops only the Excel
it started.

v0.15.0

Source control, inside the VBE

A Source Control pane, backed by the git you already have. Your modules live
against the branch head; tick the ones to commit and type a message, pre-filled
from what changed since the last commit. History opens to the modules each
commit touched, each to its comparison against the live text, with Open this
version and Restore. Blame paints author, date and hash at the end of every
committed line. The branch is a select; a remote is attached by pasting its
URL, and Fetch, Pull and Push are buttons. Git for Windows' own credential
manager signs you in, and xlide never sees a credential.

One repository folder per project. The folder your modules are exported to
is the working tree, remembered per workbook, and every save writes it. Two
workbooks can share a repository in folders of their own, and a folder shared
with the companion VS Code extension keeps working: a form it wrote as
Name.cls reads as the form.

Commit is save, then export, then commit. Pending annotations are applied,
the workbook is saved, the folder is written, and only the modules you ticked
are committed. Staging is per module, never per hunk, because a module is the
unit VBA compiles. A checkout refuses while the workbook is dirty, then imports
into every open project the repository holds, keeping your tabs and caret.

Nothing imports silently. A Folder section lists modules whose file differs
from the live text - a checkout, a pull, an edit in another editor - within a
second of the change, and offers Import and Export. A pull that conflicts holds
Import until the folder is clean and offers Abort.

git is not bundled. A machine without it is told where to get it, and the
pane finds it on the next Refresh once it is installed. Every git call runs
with terminal prompts off under a deadline, so a missing credential helper
fails in words rather than hanging, and a first push sets its upstream itself.

Also

• The scm api route is the same brain as the pane: an agent can init, commit,
  check out, blame, attach a remote and push exactly as the buttons do, and
  every action is documented and driven by the suite.
• The harness stops only the Excel it started, by id, and leaves every other
  Excel on the machine alone (#24).