- Added detection of unformed usage with `return var`, control-flow statements and member access.
- Refactored the work flow: made flow facts a class and moved operations of flow facts into the class.
- Added, cleaned and renamed test cases. Some test cases for the dynamic unformed check were suppressed by the static check. They are now added back.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
The most significant change here is that explorer now uses the chosen spelling
rather than the old `Bool` spelling. Also update a few documentation examples
and some skeletal design docs to use the chosen spelling.
- An introprocedural forward analysis that checks the may-be-formed states on local variables.
- Returns compilation error on usage of must-be-unformed variables.
- Implemented as a pass of `ASTNode` traversal.
- Currently supports detection of: function parameter, return expression and rhs of assign.
Provides a first implementation iteration towards class prefix and extension, along with user-friendly error regarding missing implementation for #1881
**Explorer behavior**
For class prefix `base` and `abstract`:
```
Class prefixes `base` and `abstract` are not supported yet
```
For extension with `extends`:
```
Class extension with `extends` is not supported yet
```
**Motivation**
* Provides user-friendly error for these unsupported features
* First implementation increment in supporting class prefix and extension.
Auto-update tries to add `CHECK: Nice!` or `CHECK: HALLO WELT` to the test case. As what's being printed is non-deterministic, the auto-update should be disabled.
Following #1191, add initial support for bitwise operators. Support for both
integer operations and for operator overloading via the interfaces specified in
#1191 is provided.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
This allows us to combine multiple Errors together without repeating the prefix
information. Also fixes several cases where two "COMPILATION ERROR" prefixes
would be prepended to the same message when errors with prefixes and locations
were produced by the lexer and parser.
Problem:
- Explorer doesn't cover implicit tuple to array conversion.
Solution:
- Add to_array.carbon which converts tuple to array if the size matches.
- Add fail_to_array.carbon which doesn't compile becase the size of array doesn't match the size of tuple.
Co-authored-by: Kris Jusiak <kris@jusiak.net>
Allows unformed state for local variables. Reports a run-time error when an unformed local variable is used.
- Added declaration without initialization for local variables in the parser.
- Made the init expression of VariableDefinition optional.
- Expanded (alive, dead) to (uninitialized, alive, dead) in the Heap.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
We don't have overload resolution, so I've simply added PrintInt for now. But it's really tempting to turn __intrinsic_print into a total kludge function.
Basic support for declaring, specifying the values of, and using associated constants.
This is incomplete in various ways. For example, when checking whether a type satisfies a constraint, there is no check that its associated constants match those in the constraint, and name lookup into a value whose type is an associated constant is not supported yet.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
Instead of complaining that the name is not completely declared, say it's not
declared at all yet.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
This PR implements the `returned var` for the explorer.
- Enabled `returned var` and `return var` syntax in lexer and parser.
- Split `Return` statement into `ReturnVar` and `ReturnExpression` to distinguish the two types of returns.
- Added logic in name resolution, type checking and interpretation to process `returned var` definition and `ReturnVar` statement.
Following #875, diagnose any use of a name prior to the point where it is introduced and its type is known.
This works by performing name resolution on a top-level class, interface, or impl twice: the first pass performs name-resolution for everything other than nested function bodies, and the second pass performs name resolution on function bodies. At the moment, the second pass does a superset of the work done by the first pass, and as a consequence, some identifier expressions now have their target set twice to the same thing.
* test cases for raw string literals
* raw string literal implementation
* match as block string if starting with triple ", and better error message for simple string
except for *#"""#*
* fix broken test case
block string literal cannot be one line
* test cases for raw string literals
* raw string literal implementation
* match as block string if starting with triple ", and better error message for simple string
except for *#"""#*
* fix broken test case
block string literal cannot be one line
* removed unused initial value
* rename flag to indicate multi-line string and remove comment
* use * to get value from std::optional
* clean-ups
* removed skip_scan flag and directly return in case of a single line string starting with #+\'\'\'
* Updated error message: simple string -> single-line string.
Co-authored-by: josh11b <josh11b@users.noreply.github.com>
* Updated test cases according to changes in error message
* Removed counting_hashtag flag.
* Implemented ScanHelper class to handle scanning
* Fixed explanation of ReadHashTags.
* Addressed PR comment.
* Clarify that scan_helper holds the source text.
* Addressed PR comments.
* Updated error messages in test cases.
* Added const keyword to return type of GetCurrentStr().
* addressed PR comments.
1. Moved ScanHelper class to lex_scan_helper.h and lex_scan_helper.cpp.
2. Moved ReadHashTags and Process* functions to lex_scan_helper.cpp. Moved YY_USER_ACTION, SIMPLE_TOKEN and ARG_TOKEN to lex_helper.h. Added a wrapper function YyinputWrapper to call static function yyinput in lexer.lpp.
3. Renamed ScanHelper with StringLexHelper.
4. Modified BUILD accordingly.
5. Renamed data members and functions.
* Addressed PR comments.
1. Adjusted order to keep ret usage close.
2. Used resize to construct the string to avoid creation of temp string.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Removed the multi_line flag and skip_read field to improve readability.
* Copied default parameter value to definition of UnescapeStringLiteral.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Copied default parameter value to definition of ParseBlockStringLiteral.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Prefix CARBON_ to SIMPLE_TOKEN and ARG_TOKEN macros.
* Rollback redefinition of arguments.
* Updated comment on the flex macro.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Updated wording.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Moved the EOF error out of the loop.
* Removed duplicated declaration.
* Changed type of `hashtag_num` and `leading_quotes` to int.
* Minor fix: string copy.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Added comment on YyinputWrapper.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Garmmar in comment.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
* Added check of eof before readling next char.
* Minor updates based on PR comments.
* Minor changes to address PR comments.
* Used a clearer way to calculate `hashtag_num` and `leading_quotes`. Switched back to indicate muti-line string with a flag.
* Directly copy StringRef for compilation error message.
* Make str_with_quote const as we don't change it.
Co-authored-by: josh11b <josh11b@users.noreply.github.com>
* Added TODO for unsupported cases.
* Fixed a typo.
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
Co-authored-by: josh11b <josh11b@users.noreply.github.com>
Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
Per the design of member access, evaluate the first operand of `.` if it's a type in order to find which type it is, and perform the lookup there.
This allows us to handle the case where the first operand is of type `Type` rather than a more specific type, but can still be evaluated to some specific type value while type-checking.
This works by splitting the constraint up into interfaces and checking
that each of them is implemented in turn.
Also check that the parameters of the impl are deducible from each of
the resulting (type, interface) pairs.
`.Self` is modeled as a new kind of expression, `DotSelfExpression`. Name resolution associates each occurrence of a `DotSelfExpression` with a generic binding, much like for an `IdentifierExpression`.
Both `:!` bindings and `where` expressions bring `.Self` into scope. The tentative intent is that if there are multiple `.Self`s in scope and they refer to different bindings, the result of using a `.Self` expression is an ambiguity error, but that is not implemented in this patch. Instead, like for `IdentifierExpression`s, we find the innermost enclosing definition of `.Self`.
`.Foo` expressions are rewritten to `.Self.Foo`, but this isn't enough to make them do anything useful, because associated constants aren't supported in general yet.
This causes compile-time evaluation to give the same result as runtime
evaluation wherever possible. In particular, referencing a generic
parameter at compile time will resolve to the actual value if we're
evaluating a call to the enclosing function so a value for the
parameter is available in the call frame.
Clean up recently-added support for `SymbolicWitness`es using this.
* initial implementation of new and delete
* remove requirement for empty heap from trace.carbon
* more tests
* fixed substitution for generic function types
This renames `Witness` to `ImplWitness` and adds a new form, `SymbolicWitness`, that holds an expression by which a witness can be computed. A common base class `Witness` is provided.
We form the new kind of witness when evaluation of a witness expression fails because the witness is not in scope, as happens when evaluating a subexpression such as a type expression in isolation, and retry evaluation in the larger context when the interpreter performs type instantiation when running the code.
This allows us to properly handle compile-time evaluation of constructs involving witness table lookups when the witness can be statically determined. The intent is that we will eventually also form symbolic witness table references when impl selection finds a non-final witness, in order to support specialization.
Simplify `NominalClassValue`: it can now always store a witness map rather than either a witness map or a witness-or-witness-expression map.
This change updated a test to use a different example to make sure a
diagnostic was still being exercised, but as a consequence lost test
coverage of the situation the test was originally intended to cover.
Add back the old test and put the new test into a different file.
Build constraint types from `where` expressions. This is very bare-bones; there's no support for constraining `.Self` or associated types yet, but degenerate cases not involving self-reference work.
`==` constraints are syntactically supported but not semantically verified yet, and they aren't used for anything.
The syntax permitted in an `interface` is similar to, but different from, that permitted elsewhere. For example, associated constant declarations (`let T:! Type;`) with no initializers are valid in interfaces but nowhere else, and are a different kind of declaration from what a normal `let` declaration would produce both syntactically and semantically.
Because interfaces and impls permit only a very small subset of the complete set of kinds of declaration, it's simpler to list only the kinds that are permitted rather than to allow an arbitrary declaration and semantically disallow the invalid cases, and it's also likely to lead to better error messages as we won't try to parse unintended or meaningless things.
* added documentation for tracing output, changed the printing of scopes to be part of the stack, made other minor changes hoping to enhance readability
* reformat a list in the README
* minor edit
* fix the lists
* updates to the interpreter/README.md
Add scaffolding for constraints in general, and support specifically constraints formed by applying a `&` operator.
No support for constraints formed with `where` nor for named constraints at this point.
pk19604014
pmqtt
Vineeth B V
Zenong Zhang
Adrien Leravat
Thejaswi Kadur
Kris JusiakandKris Jusiak
Josh Soref
cui fliter
Jeremy G. Siek