support partial expression evaluation

[martinohmann]

In #159 the idea came up to also support evaluating expressions partially, returning information about missing variables instead of failing.

[denfren]

I just thought of an idea and have thrown together some code to illustrate it: main...denfren:hcl-rs:eval-via-extended-context

Example

foo "bar" {
  value = 42
}
attribute = foo.bar.value

When a traversal is evaluated (attribute) we introduce a new state to the context where the foo.bar block's attributes are available as as variables and at the same time we translate the traversal from foo.bar.value to just value.

[martinohmann]

In general I like the idea of making resolved attributes and blocks available in the context so that references to these can be resolved automatically.

However, there are some issues that need to be addressed:

• What should be the behaviour when attribute is defined before foo in your example? E.g. if we look at terraform, it will resolve these references regardless of the order. So we probably need to roundtrip the expression evaluation again and again until not unresolved referenced are left or we hit an error that makes continuing impossible.
• In terraform land, references to blocks are different from the block declaration. E.g. variable blocks are referenced via var, locals via local and resource blocks are referenced by the first label instead of resource. This inconsistency makes me think if we should even make this behaviour automatic. Maybe it could be opt-in, e.g. via a configuration switch in the Context type or something.

I'm currently playing around with partial evaluation support in the in-place-eval branch. It essentially tries to recursively evaluate as many expressions as possible and will collect errors it encounters along the way. Objects are evaluated in place. Maybe I can enhance this further to also automatically add variables to the context while they are discovered.

[martinohmann]

Another option could be to give users a way to provide a callback to the expression evaluation process so that they can decide how to handle this (e.g. add fully evaluated attributes/blocks to the context or not, and if, how the newly exposed variable should be named).