Refuse the shapes TradingView refuses, and keep na and int ternary typing as before - #290

…e-line body

The two rows that now expect the analyzer's refusal also assert its catalog
code, so a change of the code, not only of the text, fails them.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…in-name locals, unregistered function

Three rows of the matrix asked for something the single-line path is not
responsible for. A user method on a color value created by color.rgb has no
receiver type in either body layout, so those parameter combinations are
removed rather than skipped. Two rows named a local after the second-of-minute
builtin, which the emitter resolves before locals in both layouts, so the
locals are renamed (the expected values are unchanged). The trailing-comma row
defined a function the script never called, so no member was emitted; it now
checks the parsed body of the source that ends in the comma against the body of
a runnable twin, then builds and runs the twin.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

A selection, assignment, argument, comparison or function return that pairs na
with a concrete value took the family of the first branch or of the double
fallback, so a function returning a string on one path and na on the other was
declared to return double. A concrete type now wins over na in both the coarse
type join and the structured type join, numeric and string promotion keep their
rule, and two na values keep the existing fallback. The resolved type reaches
every boundary that can carry na (ternary arms, target values, user-function
arguments, comparison operands, array reference arguments), and an array na
uses the vector type of its context.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

The first version joined types wherever two expressions met, so history-reading
method arguments, conservative terminal return typing, concrete array arms and
integer widths changed in code that has no bare na. Apply the structured join,
the terminal recovery, the argument target typing and the array-reference
staging only when a selected value contains a bare or implicit na, keep the
history bridge for history parameters, keep the integer width of a selected
time value, and drop the global color-literal additions. The expectations of
the new test file that mixed authored and generated type names or omitted an
existing initializer are corrected.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…d a contract note

Libraries are inlined only when the library source is supplied. For every other
import the refusal keeps its message and now carries one hint, defined once next
to the refusal builder and used by both places that raise it: libraries are
supported only when the library source is supplied; remove the import or paste
the library code into the script. The diagnostic catalog entries that carry the
hint and the pins that mirror them move with it, and the public contract lists
the requirement.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…estor

Typing a ternary asked for the structured type of its arms and, when that
failed, retyped the false arm and its suffix, and each join then scanned the
selected values again for a bare na. For a chain nested through the false arm
that made the work cubic in the depth, and a 500-link chain exceeded the
transpile time limit. Build one table per query by an iterative post-order walk
of both arms, holding each node's structured result and its nullability, and
let the join and the fallback consume it. The table is local to the query, no
caller's expected type is stored, and the chosen types are unchanged. Rows pin
the operation counts on both typing helpers and a deep string-and-na chain.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…old ones as they were

A hint is part of what a diagnostic code means, so adding one to the existing
unresolved-import entries repurposed them. Restore those entries, their pins and
the historical snapshots to their previous content, add two new entries for the
same messages with the plain hint (the next free codes of the analysis area,
pinned as new codes are), let the classifier pick the new codes by the hint it
already keys on, and name the two additions in the historical-reconstruction
test so any other unlisted addition still fails. The control row now supplies
both libraries of its resolved chain, and the contract lists the new identities.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…dented function uses

A function or method whose body starts on the arrow line with an if expression
was kept as a single expression holding a conditional statement, a shape the
expression emitter has no case for, so the generated function returned a
placeholder and did not compile. The inline body now keeps that conditional as
the bare if statement, the representation an indented body already has, so
analysis types the branch value and the emitter writes the ordinary conditional
tail with the family's missing value for the unmatched branch.

Expression type inference also looked a method call's receiver up on its own,
and for a scalar receiver held in a global binding it could fall back to double,
so an integer method result whose branch was unmatched reached the caller as the
integer missing sentinel read as a finite number. Inference now uses the
typed-method resolver that call emission uses.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…line to that line

The lexer floors space indentation to four-space levels, so a line indented by
two or three spaces had the level of the line before it. After most tokens that
meant a new statement, but after a function header's arrow the parser required
an indented block and refused a body written on the next line at two spaces. A
tab-free line one to three spaces beyond the previous logical line's level now
continues that line, after any token, header included. A function whose body is
one expression at two spaces is therefore the single-line function it joins
into; a conditional, loop or switch header joined to its short body is a syntax
error, and so is a function body of several statements at two spaces. Block
bodies at four spaces or a tab are unchanged.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…rms, declarations, assignments, arguments, defaults

In Pine v6 a bool has no na, and the reference behaviour refuses a bare na in
these places: an arm of a bool ternary, the initializer of a bool declaration,
an assignment to a bool name, an argument for a parameter typed bool, a bool
parameter default, the initial value of array.new<bool>, the default of
input.bool, and the value of a function whose only returned value is an
untyped na read as a condition. Each is now an analyzer error at the na token
(or the statement for a declaration or assignment): PF-E2042 for the
declaration, PF-E2043 for the ternary arm and PF-E2044 for the other members.
A function that returns a bool on some path and na on another (an if without
else) stays accepted, and so do na for int, float, string, color and user
types; Pine v5 library code keeps its previous behaviour. Rows pin the line
and column of every refusal and the accepted shapes.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…indented function body uses

A function or method whose body starts on the arrow line with a switch was
wrapped back into an expression statement, a shape the expression emitter has
no case for, so the generated function returned a placeholder and did not
compile. The inline body now keeps that switch as the bare switch statement,
the representation an indented body already has, so the analyzer types the arm
value and the emitter writes the ordinary selection tail with the family's
missing value for an unmatched selector. A header-line switch and a header-line
if now take the same path as their indented forms.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

… Pine v6

Six existing tests and four rows of the new refusal file built a script in which
a bool receives a bare na and expected it to translate. Pine v6 refuses all of
them. A test whose purpose was a bool-na behaviour now asserts the refusal with
its code and source location; a test that mixed several types keeps every
assertion and loses only the bool-na part. The historical catalog
reconstruction test names the three new bool diagnostics, so any other
unlisted addition still fails.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

… v6 refuses

Outside parentheses and brackets, a tab-free line whose indentation is not a
multiple of four spaces now continues the previous logical line whether it is
deeper or shallower; a trailing operator must be followed by a line indented by
a number of spaces that is not a multiple of four; a block may add exactly one
indentation level. Inside an open parenthesis or bracket the indentation of the
following lines is cosmetic. Two analyzer checks join them: an int variable
declared with a float literal, and an if condition of numeric type, are
refused. The four new diagnostics have their own codes (PF-E0038, PF-E0039,
PF-E2045, PF-E2046) with pins added; no old entry changes.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…he time builtin

Two rows named a local after the second-of-minute builtin, which the emitter
resolves before locals in both layouts, so the arm read the builtin instead of
the local and the selector 1 value was 0.0. The locals are renamed; the
arithmetic and the expected values are unchanged.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

# Conflicts:
#	pineforge_codegen/diagnostics_catalog.json
#	tests/fixtures/diagnostic_codes_pin.json
#	tests/test_diagnostic_notes.py

The continuation, indentation and numeric-condition refusals are not in this
head yet, so their four codes are not additions here.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…nguage's positional order

The declaration's settings were read as literals only, so a const name, an
arithmetic expression or a boolean expression was ignored, and the positional
arguments after the title never reached the settings (the seventh positional,
pyramiding, was dropped; a long positional list landed a value in the wrong
setting). One shared path now binds every positional with the repository's own
ordered signature table, merges named arguments without overwriting a bound
slot, and evaluates each setting as a compile-time constant (a literal, an
earlier const, a named constant, arithmetic, comparisons, boolean operators,
ternaries and closed pure math). A value that is not a constant, a value given
twice and a positional beyond the list are located declaration errors.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…alue is numeric

The first version refused any condition whose analyzed type was int or float,
but many bool-valued expressions (built-in calls, member reads, history and
collection reads, selections) reach that type only through the analyzer's
float fallback, so valid conditions such as ta.crossover(...) were refused. A
condition is now refused only when it is a numeric literal, a numeric built-in
series from the built-in tables, arithmetic or unary minus over such operands,
a binding or alias of such an expression that is never reassigned, or an
explicitly typed numeric parameter. Everything reached through the fallback is
accepted as before. A trailing-operator continuation keeps the new indentation
rule only where it applies outside parentheses and block context shows it is a
continuation, and the catalog-history test names the four new codes.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…d drop two unmeasured rows

Two existing tests wrapped a long expression after a trailing operator with the
next line indented by exactly four spaces at the top level, the one shape the
indentation rule refuses (a wrapped line must not be indented by a multiple of
four spaces outside parentheses). Indent that line by six spaces, which keeps
each test's purpose (line endings; a nullable selection) unchanged. Two rows of
the new rule file pinned a refusal for a wrapped operand inside a function body
whose indentation the reference behaviour does not rule out, so they are
removed rather than asserted either way.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…re-aim the tests of the replaced behaviour

The three declaration errors are now raised through an emitter form the catalog
generator scans, so it derives their templates, allocates their codes and pins
them itself (the hand-added entries are removed). The tests that expected a
non-constant setting to stay silently unresolved now assert the located error,
the tests that expected a constant name or expression to be ignored now assert
that it is honoured, and the two journal tests use sources that remain
ineligible once constant expressions are read.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…gy() declaration errors

The three templates (too many positional arguments, an argument given both
positionally and by keyword, a setting that is not a compile-time constant) are
now extracted from the source, so the catalog generator's write mode added their
codes PF-E5080 to PF-E5082 and their pins. The two files are the generator's
own output; no old entry or pin changed.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…rated head

# Conflicts:
#	pineforge_codegen/diagnostics_catalog.json
#	tests/fixtures/diagnostic_codes_pin.json
#	tests/test_diagnostic_notes.py

# Conflicts:
#	tests/test_diagnostic_notes.py

The bare color(x) cast was emitted as the literal 0 for every argument and
skipped the argument entirely. A color is held as a 64-bit integer whose missing
value is that type's minimum, so zero is a real color and na(color(na)) was
false, while color(c) of a real color always became zero. The cast now binds its
argument (positional or x=) and converts it through the integer-slot conversion
the emitter already uses, so a literal or bound na stays the color na and a real
color passes through unchanged. The construct still warns that visual output is
not rendered, with text that says what it now preserves.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

The warning added for the bare color() cast is pinned with the digest the
catalog generator derives for it (its write mode found the entry already
consistent with the source and only added the pin), and the historical
reconstruction test names it among the additions after the old snapshot.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

# Conflicts:
#	tests/test_diagnostic_notes.py

The engine's host class now has accessible members named initial_capital
and replace, and generated code spells them, so a script variable of either
name hid the member. Regenerate codegen/host_members.py with
scripts/gen_host_members.py (clang 18 on a CI runner, against the engine
that added them): two names added, nothing removed.

Tests: the committed-set check now asserts both names are derived; the
rename test gains a variable of each name (renamed to pf_safe_<name> and
compiled); the loud probe runs with both names against its neutral-name
twin; the lane composition row that used "replace" as an unreserved Pine
name now asserts the rename and the same trace as its reference.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…elper's request.security payload

The refusal "Global variable 'X' is read before its declaration in a function"
fired for an identifier that a call argument substitutes into the copied
payload of a helper defined above the global. That identifier is evaluated at
the call site, below the declaration, and TradingView accepts such a program
(two recorded probes of it ran with 336 trades each). The analyzer now skips
the refusal for an identifier that carries the payload provenance marker; a
read written in the function body itself is refused exactly as before.

The two replay tests run the unmodified recorded probes against the recorded
trades again (they had been made to move the global declarations above the
helper), the four older refusal pins of the same copied-argument shape become
compile regressions, and two boundary tests pin the body read (refused, with
line and column) and the argument at a call below the declaration (accepted).

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…ith na

The doubled-not refusal matched the tree shape not(not x), but the parser
drops parentheses, so the parenthesised operand, which TradingView accepts,
was refused as well. The parser now marks a not whose very next token is
another not, and only that spelling is refused, with the same code, message,
line and column as before.

The comparison of a value with a bare na was refused for every operand type,
but it was measured only for a number. It is now refused only when the other
operand is proven to be an int or a float; a string, an object field, an
array or an operand of unproven type keeps its ordinary lowering.

New tests pin the refused spellings beside the accepted ones, with the lines
and columns derived by hand.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…entinel

A bare na next to an int operand of a binary operator was rendered with the
int type of its neighbour, so "int n = 5" and "y = n + na" gave the int
missing-value sentinel plus five instead of NaN, although arithmetic with na
is a float in Pine. The neighbour's int type does not prove the type of the
na, so the na is rendered as a double there; the contextual typing of a
proven target (a typed declaration, a string or bool peer) is unchanged.

Tests: emitted-code rows for + - * / with the na on either side and a native
run that reads the value back, plus rows showing a double peer and the proven
contexts unchanged.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

A call such as math.abs(x) was bound to a user method named abs on float
whenever the script defined one: the receiver type is inferred for any
receiver that has no declared type, and a namespace prefix is not a value.
The inference is now skipped for a built-in namespace name that is not also a
variable, parameter, local or loop variable of the script; value receivers
(a variable, a parenthesised expression, a call result) bind user methods as
before.

Tests: a user method abs beside math.abs keeps the built-in, the same method
still binds on a float variable, a parenthesised receiver and a call receiver,
and another namespace shows the same.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

The guard that keeps a namespace call such as math.abs(x) off the user-method
receiver fallback used the whole built-in namespace table, which also holds
names that are values in Pine (the bar time, the execution time and the
weekday number). A user method called on one of those values stopped binding.
The guard now skips names the emitter already lowers as bare built-in values,
so only a pure namespace prefix is kept off the fallback.

Tests: a user method on the bar time and on the execution time binds, and the
math.abs control keeps the built-in.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

"float y = cond ? 1 : na" selected an int and the int missing-value sentinel
on the na arm, and converting that int to the float variable gave
-2147483648.0 instead of NaN, so na(y) was false. A ternary that contains a
bare na and reaches a float variable, a float call argument, a float array
element, an explicit float() cast or an arithmetic operand of a double now
goes through the conversion that maps the int sentinel to NaN; a ternary
assigned to an int variable keeps the int sentinel.

The tests that checked the bare na beside an int operand are corrected to the
text the declarations lower to and to the values a native run prints, and new
rows pin the ternary shapes in emitted code and in a native run that reads
na(y) back on a bear bar.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

A script variable named math is emitted under the escaped C++ name
pf_safe_math, so the tests that check the emitted receiver and argument of a
user method on such a variable now expect that spelling. No product code
changes: the binding itself was already correct.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

A ternary with an int arm and a bare na arm was typed int, so its na arm was
the int missing-value sentinel, and every consumer that is not a converting
float variable (a builtin argument such as plot, a ta source or math.max, an
untyped variable later used in arithmetic or a comparison, a local of a
function) read that sentinel as a number. The inference now keeps such a
ternary a float, as before, so its na arm is NaN everywhere; only a declared
int variable or an int-typed return target supplies the int representation
and keeps the int sentinel. A bare na added to a string stays the string
concatenation it was.

Tests: emitted-code rows and native runs for the builtin arguments, untyped
variables, function locals, nested ternaries, the int target that keeps the
sentinel, an integer plus na and a string plus na.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…ile; restore the edited tests

The refusal of a method called before its definition compared the position of
a script call with the position of a method declared in an imported library,
so an ordinary top-level call of an exported method was refused whenever the
library declared it on a higher line than the script called it. It now
compares only a call and a declaration of the same source file.

A tuple declared in a top-level block under the name of a built-in variable no
longer makes a later read outside the block read the block-local name: the
built-in is kept once the block has ended.

The tests and recorded sources that had been changed to avoid these refusals
are restored: the library call sites at the top level, the two recorded
request.security sources to the text their pinned hashes describe, the held
order of the global-history rows, the value assertions of the later-global
rows, the mixed-callsite helper test and the three recursion receipt rows
(now written with accepted mutually recursive and imported recursive
functions). New rows pin an imported method called at the top level, the
refusal inside one file, and an int declaration of an integer plus a bare na.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…uble

A variable declared int that was assigned a ternary with a bare na arm was
stored as an int holding the int missing-value sentinel, so every later use
(an addition, a comparison, a builtin argument, a text conversion) read the
sentinel as a number, while the earlier behaviour stored it as a double whose
missing value is NaN. The value flow of such a declaration is followed through
globals, persistent variables, locals, function parameters (arguments and
defaults) and function returns, and the storage of each of them is a double
again; a script without such a flow emits the same code as before. The earlier
special casing that kept the int sentinel for a declared int target is
removed.

The tests that pinned the int sentinel for these variables are replaced by
stricter checks of the new behaviour (double storage, NaN on the missing arm),
and native runs read back the sum with one, the comparison, the text, the
maximum and the plotted value on a bear and a bull bar.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…ple block

A bare read of the calendar variable second after a block that declared a
tuple of the same name is lowered to the engine calendar helper, not to the
raw time-structure field the first version of the test expected. The three
block rows now assert that call, and a fourth row (an else block) asserts that
the read inside the block and the read after it are different texts. No
product code changes.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

The value flow that stores a declared int fed by a nullable numeric ternary as
a double also reached function scope (a local declared int, an int parameter
and its default, an int function return), where the earlier code emits an int
with a missing-value-preserving wrapper and where existing tests record that
emission. The flow is now limited to the scopes whose storage was already a
double (globals and persistent variables); function-scope shapes are emitted
as before, and the helpers that only served the parameter and return
propagation are removed.

The new rows that pinned double storage for function-scope shapes now pin the
earlier emission instead; the global and persistent rows are unchanged.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…e function

A function whose loop body declares an int from a ternary with a na arm and
returns it is emitted with a double return type; the int local keeps its
missing-value sentinel, which becomes a finite number when it is assigned to
the double return. The row for this shape expected an int function and NaN
consumers; it now expects the double signature, the double result slot and the
values this emission produces (the finite sentinel on the missing arm), each
derived in a comment, so a later change to this behaviour is deliberate.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…int array element

A function whose last expression is a ternary with a bare na arm and an
element read from an int array (a shift or a get) was typed int, so it
returned the int missing-value sentinel as a number; the earlier behaviour
types it as a double whose missing arm is NaN. The analyzer now keeps the
floating return type for that terminal ternary when the other arm is a call on
a variable the type tables know as an array; literal arms, the time and bar
index built-ins and every float or string row are unchanged.

The two rows that pinned the int return now pin the double return with the
strict body checks of the float rows (the missing arm is a double NaN and no
int sentinel appears), and a native run reads the missing arm back as NaN.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

The fixture that checks an int function return keeps guarded int storage used
a ternary of na and an int array element as its tail, a shape that now returns
a double like the earlier behaviour. Its tail is a literal arm, which is an int
return in both the earlier behaviour and now, so the fixture keeps checking
exactly the integer-target storage it was written for; every assertion of the
test is unchanged.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…m's type

A ternary with a bare na arm took the type of its concrete arm, which made
"c ? na : 1", "c ? na : time", a na arm beside a local number, an element read
from an array held in a field, a call result or a map or matrix, a method
result, and the same ternary reached through a variable or an if branch an int
(with the int missing-value sentinel) where the earlier code typed them as a
double with a NaN missing arm. The analyzer now computes the earlier result for
every ternary (a string arm wins, then a float arm, otherwise the true arm's
type) and, wherever the new typing would say int while that result is not int,
keeps the earlier one, also for the exact return type recorded for a function
and for the call-site query that reads it. Other families (string, bool
refusal, objects, drawings, arrays, floats) and the ternaries that were already
int (a literal, the time and bar index built-ins) are unchanged. This replaces
the earlier fix that handled one shape of the problem.

Tests: rows for the na-first function tails, the globals, the array,
field, call, method, variable and branch shapes (emitted signature and tail
text), a native run reading the missing arm back as NaN, and a regression row
that a genuine int ternary stays int.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

Main gained two commits that touch only the promote-baseline workflow
(.github/workflows/promote-baseline.yml), its documentation (docs/ci.md) and
its tests (tests/test_pr_workflows.py). None of those files is changed on this
branch, so the merge has no conflict and no resolution: the result is main's
three files plus this branch's changes.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

…eeper

A statement that ends a line with a comma was refused (PF-E0040) in every block
body, whatever the next line looked like. TradingView accepts a comma at the end
of a line when the next code line starts at the same indentation (at the top
level, in a function body and in an if body), and when the next line is
indented less (a comma on the last line of a function body); it refuses the
form whose next line is indented deeper (measured at the top level), with a
mismatched-input error at that line. A comma at the end of the source was not
measured and stays accepted, as it was before the refusal existed. A strategy whose
function body starts with a declaration list that continues on the next line at
the same indentation therefore compiled on TradingView and stopped compiling
here.

The lexer now restores the line boundary of the comma-less script when the next
code line has the same or less indentation, so the following lines are parsed
exactly as they are without the comma (blank and comment lines in between do
not change that). A deeper next line keeps the earlier token stream and the
refusal keeps its code, message and location. The call-argument comma rule, the
arrow-body continuation paths and every script without a statement-ending comma
are unchanged.

Tests: rows for the function body, top level, if, for, while and switch bodies,
a comma before a dedent, before else and after comments, an operator-first
continuation, a tab-indented body and a comma at the end of the source, each
asserting that the emitted C++ equals the C++ of the same script written
without the comma; the measured refusal row and two more deeper-line rows stay
refused with the same code, message, line and column.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>