Commit Graph
32 Commits
Author SHA1 Message Date
SlaterLatiao 9106e9239e Initial implementation of returned var. (#1348)
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.
2022-07-06 13:35:41 -07:00
pk19604014 98f4bb3110 Changed fuzzer_util_test to not process the full fuzzer corpus, but instead just run on a single file, to minimize friction when making fuzzer proto changes (#1354)
At least one successful parse is still required for the test to pass.
2022-06-30 14:45:36 -04:00
Richard Smith 9ea405788e Combine most ast/ build targets into one. (#1334)
We fundamentally have cyclic references between declarations,
statements, expressions, and patterns, and there's no meaningful
layering between them. Combine them into a single build target.

Components such as paren_contents, static_scope, and library_name that
are defined without reference to specific AST nodes are kept as separate
BUILD targets.
2022-06-27 16:55:42 -07:00
Richard Smith 17ee3ed9b7 Track a resolved Member on each member access expression. (#1333)
Type checking now stores information on a member access identifying the member that was accessed, not only its name. This parallels what we do for other similar constructs whose meaning is resolved by name lookup or type-checking, and will allow us to avoid redoing lookups in some cases during interpretation.
2022-06-16 17:22:31 -07:00
Richard Smith 2fef76e58c Basic support for .Self within :! bindings and where expressions. (#1311)
`.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.
2022-06-14 21:49:01 -07:00
Jeremy G. Siek b759401328 Heap allocation basics (#1323)
* initial implementation of new and delete

* remove requirement for empty heap from trace.carbon

* more tests

* fixed substitution for generic function types
2022-06-11 18:47:07 -04:00
Richard Smith 9007b3952d Initial support for where expressions. (#1310)
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.
2022-06-09 10:31:04 -07:00
Richard Smith 1bb370420b Initial support for constraints formed by combining interfaces (#1307)
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.
2022-06-07 13:59:23 -07:00
pk19604014 e206c3123f Removed .textproto extensions from explorer fuzzer corpus files + updated the corpus with regen_corpus.py (#1303)
Also added fuzzer_corpus to codespell precommit exclusions
2022-06-02 14:54:50 -04:00
pk19604014 1af8298580 Added a script for regenerating explorer fuzzer corpus (#1297)
Using libFuzzer coverage-based corpus merge feature -- https://llvm.org/docs/LibFuzzer.html#corpus
2022-06-01 16:19:21 -04:00
Darshal Shetty e4a2d0f047 Addr Keyword Implementation (#1255)
* Implement addr keyword

* Add files that were deleted during merge

Some files got deleted during merging trunk because of the executable
semantics rename.

* Implement changes from code review.

Major changes:
- Rename AddrBindingPattern to AddrPattern
- Fix AddrPattern related changes in fuzzing

* Update documentation for GetField

* Fix AddPattern according to @zygoloid's suggestions

* Apply @zygoloid's changes to method comment

* Add a multi-component field example

* Incorporate AST changes to fuzzer corpus

* Refactor the deduced_param_list grammar rule

Suggested by @zygoloid
2022-06-01 13:51:37 -04:00
pk19604014 ed93d95fce Allow unknown fields in fuzzing text proto (#1296)
This is to help with frequent build breakages cased by proto changes.
Fuzzer corpus can be periodically auto-regenerated.
Crashing samples from the fuzzer are better 'preserved' in the form of fail_xx.carbon tests.
2022-05-25 15:44:06 -07:00
pk19604014 19d2407de7 Similar to #1272, changed the type of alternative signature from generic Expression to TupleLiteral to match the grammar (#1291) 2022-05-24 17:53:49 -07:00
Richard Smith 4cf7ed4f12 Rename some classes to match the design better (#1287)
* `FieldAccessExpression` -> `SimpleMemberAccessExpression`
    * Member `aggregate` -> `object`
    * Member `field` -> `member`
* `CompoundFieldAccessExpression` -> `CompoundMemberAccessExpression`
* `GetField` -> `GetMember`

As discussed in #1233.
2022-05-24 17:51:54 -07:00
pk19604014 8b07d1ce5d Fuzz input fix for function type literal changed in #1272 (#1289)
This reverts commit aa7c98802c.
2022-05-24 10:36:53 -07:00
pk19604014 f0a34e4bf7 Added TypeCheckTypeExp() and changed function type literal and similar type-checking logic to use the new function (#1256) 2022-05-23 16:26:35 -07:00
pk19604014 cdc9428984 Changed the type of parameter in FunctionType ctor from generic Expression to TupleLiteral to match the grammar (#1272) 2022-05-20 17:36:17 -07:00
Richard Smith 8dd398807d Support user-defined implicit conversions via ImplicitAs (#1273)
Support is added for all of the non-type expression contexts where we currently accept built-in conversions, such as reordering the fields in a struct.
2022-05-20 17:10:30 -07:00
pk19604014 45b18098ed Add continuation name to name resolution after processing continuation body (#1264)
Fixes #1263

This makes the continuation behave similar to this C++ lambda construct - auto f = []() { f(); }; which doesn't compile.
2022-05-18 10:36:11 -04:00
pk19604014 88be617360 Changed ExpectReturnOnAllPaths() to treat continuation, run and await as missing returns (#1258)
Fixes #1257
2022-05-17 09:07:16 -07:00
Richard SmithandJon Meow 50d0561249 Initial support for aliases. (#1262)
This supports aliases for types (including interfaces), functions, parameterized types, instance member names, and interface member names.

Co-authored-by: Jon Meow <jperkins@google.com>
2022-05-16 16:31:38 -07:00
235cb88a8e Compound member access syntax. (#1233)
Implement initial support for `A.(B)` syntax, per #989. Specifically, this supports:

* `object.(Type.member)` for instance members,
* `object.(Interface.member)` for instance and non-instance members,
* `object.(Type.(Interface.member))` for instance members,
* `Type.(Interface.member)` for non-instance members.

Three new AST nodes are introduced:

* `CompoundFieldAccessExpression` represents the `A.(B)` syntax.
* `MemberName` is a `Value` that represents the result of evaluating an expression such as `Type.member` or `Interface.member` or `Type.(Interface.member)`.
* `TypeOfMemberName` is the type of a `MemberName` value.

In order to handle members of classes and interfaces which have corresponding declarations and may need substitution into their types, and members of structs which don't have declarations but also don't need substitution, a class `Member` is introduced that can refer to either of these kinds of member.

Co-authored-by: Geoff Romer <gromer@google.com>
Co-authored-by: Jon Meow <jperkins@google.com>
2022-05-13 16:52:41 -07:00
Jon Meow 20728dbd3a CARBON_ header guards (#1261)
This modifies scripts/check_header_guards.py to add the CARBON_ prefix; everything else is pre-commit.
2022-05-12 17:25:43 -07:00
pk19604014 589930b703 Fix for a crash caused by choice alternative name being the same as choice name (#1243)
Fixes #1248

Changed resolve names logic to add choice name to name resolution after choice's alternatives are added.
2022-05-11 11:03:19 -07:00
pk19604014 aea04209ee Added a few files to explorer fuzzer corpus (top files by size after converting from explorer test_data sources) (#1236)
Generated with:

$ bazel build explorer/fuzzing:fuzzverter
$ cd explorer/testdata/

$ find . -name "*.carbon" | while read t; do mkdir -p "/tmp/fuzzer_corpus/$(dirname $t)" && ../../bazel-bin/explorer/fuzzing/fuzzverter --mode carbon_to_proto --input $t --output "/tmp/fuzzer_corpus/$(dirname $t)/$(basename $t .carbon).textproto" ; done

$ du -ah /tmp/fuzzer_corpus/ | grep -v fail_ | grep textproto | sort -rh | head -32 | cut -f 2 | while read t; do cp $t ../fuzzing/fuzzer_corpus/`shasum $t | cut -d ' ' -f1`.textproto; done

Tested:
$ bazel test -k explorer/...
2022-05-11 10:07:47 -07:00
Jon Meow af694b97cb Prefix most macro names with CARBON_ (#1232)
I'm doing this to avoid macro name conflicts, following https://google.github.io/styleguide/cppguide.html#Preprocessor_Macros: "If you do export a macro from a header, it must have a globally unique name. To achieve this, it must be named with a prefix consisting of your project's namespace name (but upper case)."

Commands run:

```
sed -i 's/\(DCHECK\|CHECK\|FATAL\|MAKE_UNIQUE_NAME\|MAKE_UNIQUE_NAME_IMPL\|RAW_EXITING_STREAM\|RETURN_IF_ERROR\|RETURN_IF_ERROR_IMPL\|ASSIGN_OR_RETURN\|ASSIGN_OR_RETURN_IMPL\|DIAGNOSTIC_KIND\|RETURN_IF_STACK_LIMITED\)(/CARBON_\1(/g' $(git ls-files *.cpp *.h *.lpp *.ypp *.def ':!third_party')
sed -i 's/#undef DIAGNOSTIC_KIND/#undef CARBON_DIAGNOSTIC_KIND/' toolchain/diagnostics/diagnostic_registry.def
```

Note this isn't *quite* everything, but it's intended to be a large pass at everything:

```
╚╡git grep '#define ' *.cpp *.h *.lpp *.ypp *.def ':!third_party' | grep -v '#define CARBON' | grep -v _H_
explorer/syntax/lexer.lpp:  #define YY_USER_ACTION                                             \
explorer/syntax/lexer.lpp:  #define SIMPLE_TOKEN(name) \
explorer/syntax/lexer.lpp:  #define ARG_TOKEN(name, arg) \
explorer/syntax/parse_and_lex_context.h:#define YY_DECL                                                         \
migrate_cpp/cpp_refactoring/var_decl.cpp:#define ABSTRACT_TYPE(Class, Base)
migrate_cpp/cpp_refactoring/var_decl.cpp:#define TYPE(Class, Base)     \
```

We may in particular want to do a pass to clean up #ifdef guards and make them be CARBON_ rooted.
2022-05-06 15:30:25 -07:00
josh11bandJon Meow 0a93289706 Add support for Self and impl as (#1194)
- Makes `Self` a keyword
- Inside `class Foo { `... `}`, `Self` means `Foo`
- Inside `class Foo(T:! Type, U:! Type) {` ...` }`, `Self` means `Foo(T, U)`
- `impl as Bar` means `impl Self as Bar`
- Inside `external impl Foo as Bar {`...`}`, not in a scope already defining `Self`, `Self` means `Foo`

Implemented by introducing a new kind of declaration, a `SelfDeclaration`, that is automatically added to class and impl declarations.

Co-authored-by: Jon Meow <jperkins@google.com>
2022-05-05 18:23:13 -07:00
Jon Meow 3b8d4a4910 Adjust test to work in more environments. (#1231)
The current test is really testing too closely to bazel internals.
2022-05-05 17:16:56 -07:00
josh11b ccd5545ebf Fix "and" vs. "add" typo in fuzzing README (#1228) 2022-05-05 14:31:19 -07:00
pk19604014 56604322f0 Added docs for incorporating AST changes into fuzzer logic (#1221) 2022-05-05 16:42:10 -04:00
pk19604014 150057f260 Added GetRunfilesFile() to be able to reliably determine prelude location under various invocation scenarios
The logic is using bazel Runfiles API per Jon's suggestion.

One of the scenarios used by the fuzzing framework is to place the binary and its runfiles into a folder, resulting in a directory layout like this:

[temp dir]
fuzzer
fuzzer.runfiles/

Tested:
bazel test -c opt explorer/fuzzing:explorer_fuzzer
bazel build -c opt explorer/fuzzing:explorer_fuzzer + run the binary from various locations
2022-05-02 10:36:21 -04:00
Jon Meow 309ec35f95 Rename executable_semantics to explorer (#1188)
Change generated with:

```
#!/usr/bin/bash -eux

# Helper script for renaming pending work.
# Run from the repo root.

# Rename executable_semantics in code.
sed -i 's/executable_semantics/explorer/g' \
  $(git grep -l 'executable_semantics' . | grep -v proposals)
sed -i 's/executable semantics/explorer/g' \
  $(git grep -l 'executable semantics' . | grep -v proposals)
sed -i 's/Executable semantics/Explorer/g' \
  $(git grep -l 'Executable semantics' . |  grep -v proposals)
sed -i 's/Executable Semantics/Explorer/g' \
  $(git grep -l 'Executable Semantics' . |  grep -v proposals)
sed -i 's/EXECUTABLE_SEMANTICS/EXPLORER/g' \
  $(git grep -l 'EXECUTABLE_SEMANTICS' . | grep -v proposals)
sed -i 's/ExecutableSemantics/Explorer/g' \
  $(git grep -l 'ExecutableSemantics' . | grep -v proposals)
sed -i 's/executable-semantics/explorer/g' \
  $(git grep -l 'executable-semantics' . | grep -v proposals)

# This is only needed for the initial move.
mv executable_semantics explorer
mv explorer/fuzzing/executable_semantics_fuzzer.cpp explorer/fuzzing/explorer_fuzzer.cpp
```

Verified with `bazel test ...`
2022-04-29 13:20:25 -07:00