Detect Attach effects during semantic scan

[lionel-]

Progress towards #1338
Branched from #1339

This PR does two related things:

• Recognise library() / require() Attach effects during the linear scan
• Feed those attaches into imported effects resolution

This allows the following pattern to be correctly recognised:

library(shiny)
reactive(...)

It's all flow dependent and recognises locally bound and imported symbols as you'd expect:

local(library <- identity)
library(dplyr) # Attaches

library <- identity
library(dplyr) # Symbol not found

A new attached_flow state powers this feature. During the linear scan, it contains the eager flow prefix so that eager code sees eager effects. During the walk, it contains the EOF state which serves as an over-approximation for lazy contexts (similarly to how they see the union of all bindings via enclosing snapshots).

The PR also starts the work of abstracting "effects". I'm planning for all these to be effects that alter the construction of the semantic index:

• NSE evaluation of arguments
• Attaching a package to the global search path: library(), require()
• Sourcing another file: source(), pkgload::load_code()
• Quoting an argument: quote(), bquote()
• Evaluating a quoted argument: eval()
• Capturing an environment: new.env(), parent.frame()

I'm working towards two ways of declaring effects:

• declare() annotations for simple patterns.
• Custom handlers in a contrib/ folder in Oak that will have access to Oak's resolution machinery.

Simple patterns can still be somewhat complex with the language I'm toying with, e.g.:

library <- function(pkg, character.only = FALSE) {
  declare(
    Attach(if (.(character.only)) .(pkg) else .(substitute(pkg)))
  )
}

The .() means "whatever this statically resolves to" and should allow expressing a lot of patterns, in combination with if/else interpretation. However trying to express everything R functions do in the wild is a lost cause, so custom handlers will often be the pragmatic choice.

This PR introduces a new EffectHandler trait. The effect resolver in ImportsResolver now return these handlers and the builder runs them against a CallContext to get a resolved set of effects. The CallContext object allows the handlers to match arguments and resolve them to statically known values (it's still rudimentary).

LazyShadowAmbiguity now covers Attach as well as NSE so we can lint ambiguous code:

f <- function() library(shiny)
library <- identity

Positron Release Notes

New Features

• Smarter handling of library() and require() calls.

Bug Fixes

• N/A