Statically evaluate constants referenced by macros

[devongovett]

This PR enables macro calls to include statically analyzable constants. For example:

import { foo } from './macro' with {type: 'macro'};

const common = {
  foo: 'bar'
};

const result1 = foo({...common, bar: 'test'});
const result2 = foo({...common, bar: 'other'});

Constants must be declared with const to ensure that they cannot be mutated, as this would be much harder to analyze. Object and array patterns are supported in the declaration in addition to simple identifiers. The result of a macro may also be stored in a const variable, and later used in another macro call.

This also implements support for member expressions and optional chaining to access properties of statically known objects and arrays.

It may be helpful to review with whitespace disabled FYI.

[mischnic]

Constants must be declared with const to ensure that they cannot be mutated, as this would be much harder to analyze.

Is this also handled?

const common = {
  foo: 'bar'
};
common.foo = 'baz'; // <---
const result1 = foo({...common, bar: 'test'});

[devongovett]

@mischnic I was just thinking about that as well. Added some code to make assignments to constant objects an error if that constant is later accessed by a macro. In addition, if a constant object (or a property of a constant object that is also an object) is passed as an argument of a function call, it is also marked as potentially mutated.

[devongovett]

The above could potentially be fine if object2.obj is not accessed in a macro, e.g. if object2.foo were passed here. But tracking mutations for individual values would be a bit more complicated than only tracking it for constants as a whole.