carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-05 22:02:55 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Rename Ptr<T> to Nonnull<T*> (#832)

Browse Source 
Note that ptr.h also includes an enable_if change, to help avoid https://bugs.llvm.org/show_bug.cgi?id=51881
This commit is contained in:
Jon Meow
2021-09-16 19:22:57 -07:00
committed by GitHub
parent 5e66248db0
commit 56dc4ae375
35 changed files with 584 additions and 535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/ast.h
+1 -1
View File
@@ -22,7 +22,7 @@ struct AST {
// Import directives.
std::vector<LibraryName> imports;
// The file's ordered declarations.
std::vector<Ptr<const Declaration>> declarations;
std::vector<Nonnull<const Declaration*>> declarations;
};
} // namespace Carbon
executable_semantics/ast/class_definition.h
+1 -1
View File
@@ -16,7 +16,7 @@ namespace Carbon {
struct ClassDefinition {
SourceLocation loc;
std::string name;
std::vector<Ptr<Member>> members;
std::vector<Nonnull<Member*>> members;
};
} // namespace Carbon
executable_semantics/ast/declaration.cpp
+1 -1
View File
@@ -20,7 +20,7 @@ void Declaration::Print(llvm::raw_ostream& out) const {
const ClassDefinition& class_def =
cast<ClassDeclaration>(*this).Definition();
out << "class " << class_def.name << " {\n";
for (Ptr<Member> m : class_def.members) {
for (Nonnull<Member*> m : class_def.members) {
out << *m;
}
out << "}\n";
executable_semantics/ast/declaration.h
+15 -13
View File
@@ -60,7 +60,7 @@ class Declaration {
class FunctionDeclaration : public Declaration {
public:
FunctionDeclaration(Ptr<const FunctionDefinition> definition)
FunctionDeclaration(Nonnull<const FunctionDefinition*> definition)
: Declaration(Kind::FunctionDeclaration, definition->source_location),
definition(definition) {}
@@ -71,13 +71,13 @@ class FunctionDeclaration : public Declaration {
auto Definition() const -> const FunctionDefinition& { return *definition; }
private:
Ptr<const FunctionDefinition> definition;
Nonnull<const FunctionDefinition*> definition;
};
class ClassDeclaration : public Declaration {
public:
ClassDeclaration(SourceLocation loc, std::string name,
std::vector<Ptr<Member>> members)
std::vector<Nonnull<Member*>> members)
: Declaration(Kind::ClassDeclaration, loc),
definition({.loc = loc,
.name = std::move(name),
@@ -97,7 +97,8 @@ class ChoiceDeclaration : public Declaration {
public:
ChoiceDeclaration(
SourceLocation loc, std::string name,
std::vector<std::pair<std::string, Ptr<const Expression>>> alternatives)
std::vector<std::pair<std::string, Nonnull<const Expression*>>>
alternatives)
: Declaration(Kind::ChoiceDeclaration, loc),
name(std::move(name)),
alternatives(std::move(alternatives)) {}
@@ -107,21 +108,22 @@ class ChoiceDeclaration : public Declaration {
}
auto Name() const -> const std::string& { return name; }
auto Alternatives() const
-> const std::vector<std::pair<std::string, Ptr<const Expression>>>& {
auto Alternatives() const -> const
std::vector<std::pair<std::string, Nonnull<const Expression*>>>& {
return alternatives;
}
private:
std::string name;
std::vector<std::pair<std::string, Ptr<const Expression>>> alternatives;
std::vector<std::pair<std::string, Nonnull<const Expression*>>> alternatives;
};
// Global variable definition implements the Declaration concept.
class VariableDeclaration : public Declaration {
public:
VariableDeclaration(SourceLocation loc, Ptr<const BindingPattern> binding,
Ptr<const Expression> initializer)
VariableDeclaration(SourceLocation loc,
Nonnull<const BindingPattern*> binding,
Nonnull<const Expression*> initializer)
: Declaration(Kind::VariableDeclaration, loc),
binding(binding),
initializer(initializer) {}
@@ -130,15 +132,15 @@ class VariableDeclaration : public Declaration {
return decl->Tag() == Kind::VariableDeclaration;
}
auto Binding() const -> Ptr<const BindingPattern> { return binding; }
auto Initializer() const -> Ptr<const Expression> { return initializer; }
auto Binding() const -> Nonnull<const BindingPattern*> { return binding; }
auto Initializer() const -> Nonnull<const Expression*> { return initializer; }
private:
// TODO: split this into a non-optional name and a type, initialized by
// a constructor that takes a BindingPattern and handles errors like a
// missing name.
Ptr<const BindingPattern> binding;
Ptr<const Expression> initializer;
Nonnull<const BindingPattern*> binding;
Nonnull<const Expression*> initializer;
};
} // namespace Carbon
executable_semantics/ast/expression.cpp
+7 -5
View File
@@ -17,9 +17,10 @@ namespace Carbon {
using llvm::cast;
auto ExpressionFromParenContents(
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression> {
std::optional<Ptr<const Expression>> single_term =
Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents)
-> Nonnull<const Expression*> {
std::optional<Nonnull<const Expression*>> single_term =
paren_contents.SingleTerm();
if (single_term.has_value()) {
return *single_term;
@@ -29,8 +30,9 @@ auto ExpressionFromParenContents(
}
auto TupleExpressionFromParenContents(
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression> {
Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents)
-> Nonnull<const Expression*> {
return arena->New<TupleLiteral>(
loc, paren_contents.TupleElements<FieldInitializer>(loc));
}
executable_semantics/ast/expression.h
+34 -30
View File
@@ -63,25 +63,27 @@ class Expression {
// grouping if their contents permit that interpretation, or as forming a
// tuple otherwise.
auto ExpressionFromParenContents(
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression>;
Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents)
-> Nonnull<const Expression*>;
// Converts paren_contents to an Expression, interpreting the parentheses as
// forming a tuple.
auto TupleExpressionFromParenContents(
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression>;
Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents)
-> Nonnull<const Expression*>;
// A FieldInitializer represents the initialization of a single tuple field.
struct FieldInitializer {
FieldInitializer(std::string name, Ptr<const Expression> expression)
FieldInitializer(std::string name, Nonnull<const Expression*> expression)
: name(std::move(name)), expression(expression) {}
// The field name. Cannot be empty.
std::string name;
// The expression that initializes the field.
Ptr<const Expression> expression;
Nonnull<const Expression*> expression;
};
enum class Operator {
@@ -115,7 +117,7 @@ class IdentifierExpression : public Expression {
class FieldAccessExpression : public Expression {
public:
explicit FieldAccessExpression(SourceLocation loc,
Ptr<const Expression> aggregate,
Nonnull<const Expression*> aggregate,
std::string field)
: Expression(Kind::FieldAccessExpression, loc),
aggregate(aggregate),
@@ -125,18 +127,19 @@ class FieldAccessExpression : public Expression {
return exp->Tag() == Kind::FieldAccessExpression;
}
auto Aggregate() const -> Ptr<const Expression> { return aggregate; }
auto Aggregate() const -> Nonnull<const Expression*> { return aggregate; }
auto Field() const -> const std::string& { return field; }
private:
Ptr<const Expression> aggregate;
Nonnull<const Expression*> aggregate;
std::string field;
};
class IndexExpression : public Expression {
public:
explicit IndexExpression(SourceLocation loc, Ptr<const Expression> aggregate,
Ptr<const Expression> offset)
explicit IndexExpression(SourceLocation loc,
Nonnull<const Expression*> aggregate,
Nonnull<const Expression*> offset)
: Expression(Kind::IndexExpression, loc),
aggregate(aggregate),
offset(offset) {}
@@ -145,12 +148,12 @@ class IndexExpression : public Expression {
return exp->Tag() == Kind::IndexExpression;
}
auto Aggregate() const -> Ptr<const Expression> { return aggregate; }
auto Offset() const -> Ptr<const Expression> { return offset; }
auto Aggregate() const -> Nonnull<const Expression*> { return aggregate; }
auto Offset() const -> Nonnull<const Expression*> { return offset; }
private:
Ptr<const Expression> aggregate;
Ptr<const Expression> offset;
Nonnull<const Expression*> aggregate;
Nonnull<const Expression*> offset;
};
class IntLiteral : public Expression {
@@ -230,7 +233,7 @@ class PrimitiveOperatorExpression : public Expression {
public:
explicit PrimitiveOperatorExpression(
SourceLocation loc, Operator op,
std::vector<Ptr<const Expression>> arguments)
std::vector<Nonnull<const Expression*>> arguments)
: Expression(Kind::PrimitiveOperatorExpression, loc),
op(op),
arguments(std::move(arguments)) {}
@@ -240,19 +243,20 @@ class PrimitiveOperatorExpression : public Expression {
}
auto Op() const -> Operator { return op; }
auto Arguments() const -> const std::vector<Ptr<const Expression>>& {
auto Arguments() const -> const std::vector<Nonnull<const Expression*>>& {
return arguments;
}
private:
Operator op;
std::vector<Ptr<const Expression>> arguments;
std::vector<Nonnull<const Expression*>> arguments;
};
class CallExpression : public Expression {
public:
explicit CallExpression(SourceLocation loc, Ptr<const Expression> function,
Ptr<const Expression> argument)
explicit CallExpression(SourceLocation loc,
Nonnull<const Expression*> function,
Nonnull<const Expression*> argument)
: Expression(Kind::CallExpression, loc),
function(function),
argument(argument) {}
@@ -261,19 +265,19 @@ class CallExpression : public Expression {
return exp->Tag() == Kind::CallExpression;
}
auto Function() const -> Ptr<const Expression> { return function; }
auto Argument() const -> Ptr<const Expression> { return argument; }
auto Function() const -> Nonnull<const Expression*> { return function; }
auto Argument() const -> Nonnull<const Expression*> { return argument; }
private:
Ptr<const Expression> function;
Ptr<const Expression> argument;
Nonnull<const Expression*> function;
Nonnull<const Expression*> argument;
};
class FunctionTypeLiteral : public Expression {
public:
explicit FunctionTypeLiteral(SourceLocation loc,
Ptr<const Expression> parameter,
Ptr<const Expression> return_type,
Nonnull<const Expression*> parameter,
Nonnull<const Expression*> return_type,
bool is_omitted_return_type)
: Expression(Kind::FunctionTypeLiteral, loc),
parameter(parameter),
@@ -284,13 +288,13 @@ class FunctionTypeLiteral : public Expression {
return exp->Tag() == Kind::FunctionTypeLiteral;
}
auto Parameter() const -> Ptr<const Expression> { return parameter; }
auto ReturnType() const -> Ptr<const Expression> { return return_type; }
auto Parameter() const -> Nonnull<const Expression*> { return parameter; }
auto ReturnType() const -> Nonnull<const Expression*> { return return_type; }
auto IsOmittedReturnType() const -> bool { return is_omitted_return_type; }
private:
Ptr<const Expression> parameter;
Ptr<const Expression> return_type;
Nonnull<const Expression*> parameter;
Nonnull<const Expression*> return_type;
bool is_omitted_return_type;
};
executable_semantics/ast/expression_test.cpp
+8 -8
View File
@@ -38,7 +38,7 @@ class ExpressionTest : public ::testing::Test {
TEST_F(ExpressionTest, EmptyAsExpression) {
ParenContents<Expression> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const Expression> expression =
Nonnull<const Expression*> expression =
ExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(expression->Tag(), Expression::Kind::TupleLiteral);
@@ -48,7 +48,7 @@ TEST_F(ExpressionTest, EmptyAsExpression) {
TEST_F(ExpressionTest, EmptyAsTuple) {
ParenContents<Expression> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const Expression> tuple =
Nonnull<const Expression*> tuple =
TupleExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
@@ -67,7 +67,7 @@ TEST_F(ExpressionTest, UnaryNoCommaAsExpression) {
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = false};
Ptr<const Expression> expression =
Nonnull<const Expression*> expression =
ExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(2));
ASSERT_EQ(expression->Tag(), Expression::Kind::IntLiteral);
@@ -79,7 +79,7 @@ TEST_F(ExpressionTest, UnaryNoCommaAsTuple) {
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = false};
Ptr<const Expression> tuple =
Nonnull<const Expression*> tuple =
TupleExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
@@ -93,7 +93,7 @@ TEST_F(ExpressionTest, UnaryWithCommaAsExpression) {
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> expression =
Nonnull<const Expression*> expression =
ExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(expression->Tag(), Expression::Kind::TupleLiteral);
@@ -107,7 +107,7 @@ TEST_F(ExpressionTest, UnaryWithCommaAsTuple) {
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> tuple =
Nonnull<const Expression*> tuple =
TupleExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
@@ -123,7 +123,7 @@ TEST_F(ExpressionTest, BinaryAsExpression) {
.term = arena.New<IntLiteral>(FakeSourceLoc(3), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> expression =
Nonnull<const Expression*> expression =
ExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(expression->Tag(), Expression::Kind::TupleLiteral);
@@ -139,7 +139,7 @@ TEST_F(ExpressionTest, BinaryAsTuple) {
.term = arena.New<IntLiteral>(FakeSourceLoc(3), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> tuple =
Nonnull<const Expression*> tuple =
TupleExpressionFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
executable_semantics/ast/function_definition.h
+7 -7
View File
@@ -18,16 +18,16 @@ namespace Carbon {
// For now, only generic parameters are supported.
struct GenericBinding {
std::string name;
Ptr<const Expression> type;
Nonnull<const Expression*> type;
};
struct FunctionDefinition {
FunctionDefinition(SourceLocation source_location, std::string name,
std::vector<GenericBinding> deduced_params,
Ptr<const TuplePattern> param_pattern,
Ptr<const Pattern> return_type,
Nonnull<const TuplePattern*> param_pattern,
Nonnull<const Pattern*> return_type,
bool is_omitted_return_type,
std::optional<Ptr<const Statement>> body)
std::optional<Nonnull<const Statement*>> body)
: source_location(source_location),
name(std::move(name)),
deduced_parameters(deduced_params),
@@ -43,10 +43,10 @@ struct FunctionDefinition {
SourceLocation source_location;
std::string name;
std::vector<GenericBinding> deduced_parameters;
Ptr<const TuplePattern> param_pattern;
Ptr<const Pattern> return_type;
Nonnull<const TuplePattern*> param_pattern;
Nonnull<const Pattern*> return_type;
bool is_omitted_return_type;
std::optional<Ptr<const Statement>> body;
std::optional<Nonnull<const Statement*>> body;
};
} // namespace Carbon
executable_semantics/ast/member.h
+3 -3
View File
@@ -51,20 +51,20 @@ class Member {
class FieldMember : public Member {
public:
FieldMember(SourceLocation loc, Ptr<const BindingPattern> binding)
FieldMember(SourceLocation loc, Nonnull<const BindingPattern*> binding)
: Member(Kind::FieldMember, loc), binding(binding) {}
static auto classof(const Member* member) -> bool {
return member->Tag() == Kind::FieldMember;
}
auto Binding() const -> Ptr<const BindingPattern> { return binding; }
auto Binding() const -> Nonnull<const BindingPattern*> { return binding; }
private:
// TODO: split this into a non-optional name and a type, initialized by
// a constructor that takes a BindingPattern and handles errors like a
// missing name.
Ptr<const BindingPattern> binding;
Nonnull<const BindingPattern*> binding;
};
} // namespace Carbon
executable_semantics/ast/paren_contents.h
+5 -4
View File
@@ -28,16 +28,16 @@ template <typename Term>
struct ParenContents {
struct Element {
std::optional<std::string> name;
Ptr<const Term> term;
Nonnull<const Term*> term;
};
// If this object represents a single term, with no name and no trailing
// comma, this method returns that term. This typically means the parentheses
// can be interpreted as grouping.
auto SingleTerm() const -> std::optional<Ptr<const Term>>;
auto SingleTerm() const -> std::optional<Nonnull<const Term*>>;
// Converts `elements` to std::vector<TupleElement>. TupleElement must
// have a constructor that takes a std::string and a Ptr<const Term>.
// have a constructor that takes a std::string and a Nonnull<const Term*>.
//
// TODO: Find a way to deduce TupleElement from Term.
template <typename TupleElement>
@@ -50,7 +50,8 @@ struct ParenContents {
// Implementation details only below here.
template <typename Term>
auto ParenContents<Term>::SingleTerm() const -> std::optional<Ptr<const Term>> {
auto ParenContents<Term>::SingleTerm() const
-> std::optional<Nonnull<const Term*>> {
if (elements.size() == 1 && !elements.front().name.has_value() &&
!has_trailing_comma) {
return elements.front().term;
executable_semantics/ast/pattern.cpp
+12 -11
View File
@@ -54,8 +54,8 @@ void Pattern::Print(llvm::raw_ostream& out) const {
}
}
TuplePattern::TuplePattern(Ptr<Arena> arena,
Ptr<const Expression> tuple_literal)
TuplePattern::TuplePattern(Nonnull<Arena*> arena,
Nonnull<const Expression*> tuple_literal)
: Pattern(Kind::TuplePattern, tuple_literal->SourceLoc()) {
const auto& tuple = cast<TupleLiteral>(*tuple_literal);
for (const FieldInitializer& init : tuple.Fields()) {
@@ -64,10 +64,11 @@ TuplePattern::TuplePattern(Ptr<Arena> arena,
}
}
auto PatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
auto PatternFromParenContents(Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const Pattern> {
std::optional<Ptr<const Pattern>> single_term = paren_contents.SingleTerm();
-> Nonnull<const Pattern*> {
std::optional<Nonnull<const Pattern*>> single_term =
paren_contents.SingleTerm();
if (single_term.has_value()) {
return *single_term;
} else {
@@ -75,9 +76,9 @@ auto PatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
}
}
auto TuplePatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
auto TuplePatternFromParenContents(Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const TuplePattern> {
-> Nonnull<const TuplePattern*> {
return arena->New<TuplePattern>(
loc, paren_contents.TupleElements<TuplePattern::Field>(loc));
}
@@ -86,7 +87,7 @@ auto TuplePatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
// error for incorrect expressions, rather than letting a default cast error
// apply.
static const FieldAccessExpression& RequireFieldAccess(
Ptr<const Expression> alternative) {
Nonnull<const Expression*> alternative) {
if (alternative->Tag() != Expression::Kind::FieldAccessExpression) {
FATAL_PROGRAM_ERROR(alternative->SourceLoc())
<< "Alternative pattern must have the form of a field access.";
@@ -95,14 +96,14 @@ static const FieldAccessExpression& RequireFieldAccess(
}
AlternativePattern::AlternativePattern(SourceLocation loc,
Ptr<const Expression> alternative,
Ptr<const TuplePattern> arguments)
Nonnull<const Expression*> alternative,
Nonnull<const TuplePattern*> arguments)
: Pattern(Kind::AlternativePattern, loc),
choice_type(RequireFieldAccess(alternative).Aggregate()),
alternative_name(RequireFieldAccess(alternative).Field()),
arguments(arguments) {}
auto ParenExpressionToParenPattern(Ptr<Arena> arena,
auto ParenExpressionToParenPattern(Nonnull<Arena*> arena,
const ParenContents<Expression>& contents)
-> ParenContents<Pattern> {
ParenContents<Pattern> result = {
executable_semantics/ast/pattern.h
+22 -22
View File
@@ -71,7 +71,7 @@ class AutoPattern : public Pattern {
class BindingPattern : public Pattern {
public:
BindingPattern(SourceLocation loc, std::optional<std::string> name,
Ptr<const Pattern> type)
Nonnull<const Pattern*> type)
: Pattern(Kind::BindingPattern, loc), name(std::move(name)), type(type) {}
static auto classof(const Pattern* pattern) -> bool {
@@ -82,11 +82,11 @@ class BindingPattern : public Pattern {
auto Name() const -> const std::optional<std::string>& { return name; }
// The pattern specifying the type of values that this pattern matches.
auto Type() const -> Ptr<const Pattern> { return type; }
auto Type() const -> Nonnull<const Pattern*> { return type; }
private:
std::optional<std::string> name;
Ptr<const Pattern> type;
Nonnull<const Pattern*> type;
};
// A pattern that matches a tuple value field-wise.
@@ -94,14 +94,14 @@ class TuplePattern : public Pattern {
public:
// Represents a portion of a tuple pattern corresponding to a single field.
struct Field {
Field(std::string name, Ptr<const Pattern> pattern)
Field(std::string name, Nonnull<const Pattern*> pattern)
: name(std::move(name)), pattern(pattern) {}
// The field name. Cannot be empty
std::string name;
// The pattern the field must match.
Ptr<const Pattern> pattern;
Nonnull<const Pattern*> pattern;
};
TuplePattern(SourceLocation loc, std::vector<Field> fields)
@@ -111,7 +111,7 @@ class TuplePattern : public Pattern {
// ExpressionPattern.
//
// REQUIRES: tuple_literal->Tag() == Expression::Kind::TupleLiteral
TuplePattern(Ptr<Arena> arena, Ptr<const Expression> tuple_literal);
TuplePattern(Nonnull<Arena*> arena, Nonnull<const Expression*> tuple_literal);
static auto classof(const Pattern* pattern) -> bool {
return pattern->Tag() == Kind::TuplePattern;
@@ -126,19 +126,19 @@ class TuplePattern : public Pattern {
// Converts paren_contents to a Pattern, interpreting the parentheses as
// grouping if their contents permit that interpretation, or as forming a
// tuple otherwise.
auto PatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
auto PatternFromParenContents(Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const Pattern>;
-> Nonnull<const Pattern*>;
// Converts paren_contents to a TuplePattern, interpreting the parentheses as
// forming a tuple.
auto TuplePatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
auto TuplePatternFromParenContents(Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const TuplePattern>;
-> Nonnull<const TuplePattern*>;
// Converts `contents` to ParenContents<Pattern> by replacing each Expression
// with an ExpressionPattern.
auto ParenExpressionToParenPattern(Ptr<Arena> arena,
auto ParenExpressionToParenPattern(Nonnull<Arena*> arena,
const ParenContents<Expression>& contents)
-> ParenContents<Pattern>;
@@ -148,9 +148,9 @@ class AlternativePattern : public Pattern {
// Constructs an AlternativePattern that matches a value of the type
// specified by choice_type if it represents an alternative named
// alternative_name, and its arguments match `arguments`.
AlternativePattern(SourceLocation loc, Ptr<const Expression> choice_type,
AlternativePattern(SourceLocation loc, Nonnull<const Expression*> choice_type,
std::string alternative_name,
Ptr<const TuplePattern> arguments)
Nonnull<const TuplePattern*> arguments)
: Pattern(Kind::AlternativePattern, loc),
choice_type(choice_type),
alternative_name(std::move(alternative_name)),
@@ -158,30 +158,30 @@ class AlternativePattern : public Pattern {
// Constructs an AlternativePattern that matches the alternative specified
// by `alternative`, if its arguments match `arguments`.
AlternativePattern(SourceLocation loc, Ptr<const Expression> alternative,
Ptr<const TuplePattern> arguments);
AlternativePattern(SourceLocation loc, Nonnull<const Expression*> alternative,
Nonnull<const TuplePattern*> arguments);
static auto classof(const Pattern* pattern) -> bool {
return pattern->Tag() == Kind::AlternativePattern;
}
auto ChoiceType() const -> Ptr<const Expression> { return choice_type; }
auto ChoiceType() const -> Nonnull<const Expression*> { return choice_type; }
auto AlternativeName() const -> const std::string& {
return alternative_name;
}
auto Arguments() const -> Ptr<const TuplePattern> { return arguments; }
auto Arguments() const -> Nonnull<const TuplePattern*> { return arguments; }
private:
Ptr<const Expression> choice_type;
Nonnull<const Expression*> choice_type;
std::string alternative_name;
Ptr<const TuplePattern> arguments;
Nonnull<const TuplePattern*> arguments;
};
// A pattern that matches a value if it is equal to the value of a given
// expression.
class ExpressionPattern : public Pattern {
public:
ExpressionPattern(Ptr<const Expression> expression)
ExpressionPattern(Nonnull<const Expression*> expression)
: Pattern(Kind::ExpressionPattern, expression->SourceLoc()),
expression(expression) {}
@@ -189,10 +189,10 @@ class ExpressionPattern : public Pattern {
return pattern->Tag() == Kind::ExpressionPattern;
}
auto Expression() const -> Ptr<const Expression> { return expression; }
auto Expression() const -> Nonnull<const Expression*> { return expression; }
private:
Ptr<const Carbon::Expression> expression;
Nonnull<const Carbon::Expression*> expression;
};
} // namespace Carbon
executable_semantics/ast/pattern_test.cpp
+8 -8
View File
@@ -37,7 +37,7 @@ class PatternTest : public ::testing::Test {
TEST_F(PatternTest, EmptyAsPattern) {
ParenContents<Pattern> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const Pattern> pattern =
Nonnull<const Pattern*> pattern =
PatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(1));
ASSERT_TRUE(isa<TuplePattern>(*pattern));
@@ -47,7 +47,7 @@ TEST_F(PatternTest, EmptyAsPattern) {
TEST_F(PatternTest, EmptyAsTuplePattern) {
ParenContents<Pattern> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const TuplePattern> tuple =
Nonnull<const TuplePattern*> tuple =
TuplePatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(), IsEmpty());
@@ -65,7 +65,7 @@ TEST_F(PatternTest, UnaryNoCommaAsPattern) {
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = false};
Ptr<const Pattern> pattern =
Nonnull<const Pattern*> pattern =
PatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(2));
ASSERT_TRUE(isa<AutoPattern>(*pattern));
@@ -77,7 +77,7 @@ TEST_F(PatternTest, UnaryNoCommaAsTuplePattern) {
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = false};
Ptr<const TuplePattern> tuple =
Nonnull<const TuplePattern*> tuple =
TuplePatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(), ElementsAre(AutoFieldNamed("0")));
@@ -89,7 +89,7 @@ TEST_F(PatternTest, UnaryWithCommaAsPattern) {
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const Pattern> pattern =
Nonnull<const Pattern*> pattern =
PatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(1));
ASSERT_TRUE(isa<TuplePattern>(*pattern));
@@ -103,7 +103,7 @@ TEST_F(PatternTest, UnaryWithCommaAsTuplePattern) {
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const TuplePattern> tuple =
Nonnull<const TuplePattern*> tuple =
TuplePatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(), ElementsAre(AutoFieldNamed("0")));
@@ -117,7 +117,7 @@ TEST_F(PatternTest, BinaryAsPattern) {
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const Pattern> pattern =
Nonnull<const Pattern*> pattern =
PatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(1));
ASSERT_TRUE(isa<TuplePattern>(*pattern));
@@ -133,7 +133,7 @@ TEST_F(PatternTest, BinaryAsTuplePattern) {
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const TuplePattern> tuple =
Nonnull<const TuplePattern*> tuple =
TuplePatternFromParenContents(&arena, FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(),
executable_semantics/ast/source_location.h
+1 -1
View File
@@ -18,7 +18,7 @@ class SourceLocation {
// The filename should be eternal or arena-allocated to eliminate copies.
SourceLocation(const char* filename, int line_num)
: filename(filename), line_num(line_num) {}
SourceLocation(Ptr<const std::string> filename, int line_num)
SourceLocation(Nonnull<const std::string*> filename, int line_num)
: filename(filename->c_str()), line_num(line_num) {}
SourceLocation(const SourceLocation&) = default;
executable_semantics/ast/statement.h
+59 -56
View File
@@ -58,60 +58,60 @@ class Statement {
class ExpressionStatement : public Statement {
public:
ExpressionStatement(SourceLocation loc, Ptr<const Expression> exp)
ExpressionStatement(SourceLocation loc, Nonnull<const Expression*> exp)
: Statement(Kind::ExpressionStatement, loc), exp(exp) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::ExpressionStatement;
}
auto Exp() const -> Ptr<const Expression> { return exp; }
auto Exp() const -> Nonnull<const Expression*> { return exp; }
private:
Ptr<const Expression> exp;
Nonnull<const Expression*> exp;
};
class Assign : public Statement {
public:
Assign(SourceLocation loc, Ptr<const Expression> lhs,
Ptr<const Expression> rhs)
Assign(SourceLocation loc, Nonnull<const Expression*> lhs,
Nonnull<const Expression*> rhs)
: Statement(Kind::Assign, loc), lhs(lhs), rhs(rhs) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::Assign;
}
auto Lhs() const -> Ptr<const Expression> { return lhs; }
auto Rhs() const -> Ptr<const Expression> { return rhs; }
auto Lhs() const -> Nonnull<const Expression*> { return lhs; }
auto Rhs() const -> Nonnull<const Expression*> { return rhs; }
private:
Ptr<const Expression> lhs;
Ptr<const Expression> rhs;
Nonnull<const Expression*> lhs;
Nonnull<const Expression*> rhs;
};
class VariableDefinition : public Statement {
public:
VariableDefinition(SourceLocation loc, Ptr<const Pattern> pat,
Ptr<const Expression> init)
VariableDefinition(SourceLocation loc, Nonnull<const Pattern*> pat,
Nonnull<const Expression*> init)
: Statement(Kind::VariableDefinition, loc), pat(pat), init(init) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::VariableDefinition;
}
auto Pat() const -> Ptr<const Pattern> { return pat; }
auto Init() const -> Ptr<const Expression> { return init; }
auto Pat() const -> Nonnull<const Pattern*> { return pat; }
auto Init() const -> Nonnull<const Expression*> { return init; }
private:
Ptr<const Pattern> pat;
Ptr<const Expression> init;
Nonnull<const Pattern*> pat;
Nonnull<const Expression*> init;
};
class If : public Statement {
public:
If(SourceLocation loc, Ptr<const Expression> cond,
Ptr<const Statement> then_stmt,
std::optional<Ptr<const Statement>> else_stmt)
If(SourceLocation loc, Nonnull<const Expression*> cond,
Nonnull<const Statement*> then_stmt,
std::optional<Nonnull<const Statement*>> else_stmt)
: Statement(Kind::If, loc),
cond(cond),
then_stmt(then_stmt),
@@ -121,23 +121,24 @@ class If : public Statement {
return stmt->Tag() == Kind::If;
}
auto Cond() const -> Ptr<const Expression> { return cond; }
auto ThenStmt() const -> Ptr<const Statement> { return then_stmt; }
auto ElseStmt() const -> std::optional<Ptr<const Statement>> {
auto Cond() const -> Nonnull<const Expression*> { return cond; }
auto ThenStmt() const -> Nonnull<const Statement*> { return then_stmt; }
auto ElseStmt() const -> std::optional<Nonnull<const Statement*>> {
return else_stmt;
}
private:
Ptr<const Expression> cond;
Ptr<const Statement> then_stmt;
std::optional<Ptr<const Statement>> else_stmt;
Nonnull<const Expression*> cond;
Nonnull<const Statement*> then_stmt;
std::optional<Nonnull<const Statement*>> else_stmt;
};
class Return : public Statement {
public:
Return(Ptr<Arena> arena, SourceLocation loc)
Return(Nonnull<Arena*> arena, SourceLocation loc)
: Return(loc, arena->New<TupleLiteral>(loc), true) {}
Return(SourceLocation loc, Ptr<const Expression> exp, bool is_omitted_exp)
Return(SourceLocation loc, Nonnull<const Expression*> exp,
bool is_omitted_exp)
: Statement(Kind::Return, loc),
exp(exp),
is_omitted_exp(is_omitted_exp) {}
@@ -146,63 +147,63 @@ class Return : public Statement {
return stmt->Tag() == Kind::Return;
}
auto Exp() const -> Ptr<const Expression> { return exp; }
auto Exp() const -> Nonnull<const Expression*> { return exp; }
auto IsOmittedExp() const -> bool { return is_omitted_exp; }
private:
Ptr<const Expression> exp;
Nonnull<const Expression*> exp;
bool is_omitted_exp;
};
class Sequence : public Statement {
public:
Sequence(SourceLocation loc, Ptr<const Statement> stmt,
std::optional<Ptr<const Statement>> next)
Sequence(SourceLocation loc, Nonnull<const Statement*> stmt,
std::optional<Nonnull<const Statement*>> next)
: Statement(Kind::Sequence, loc), stmt(stmt), next(next) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::Sequence;
}
auto Stmt() const -> Ptr<const Statement> { return stmt; }
auto Next() const -> std::optional<Ptr<const Statement>> { return next; }
auto Stmt() const -> Nonnull<const Statement*> { return stmt; }
auto Next() const -> std::optional<Nonnull<const Statement*>> { return next; }
private:
Ptr<const Statement> stmt;
std::optional<Ptr<const Statement>> next;
Nonnull<const Statement*> stmt;
std::optional<Nonnull<const Statement*>> next;
};
class Block : public Statement {
public:
Block(SourceLocation loc, std::optional<Ptr<const Statement>> stmt)
Block(SourceLocation loc, std::optional<Nonnull<const Statement*>> stmt)
: Statement(Kind::Block, loc), stmt(stmt) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::Block;
}
auto Stmt() const -> std::optional<Ptr<const Statement>> { return stmt; }
auto Stmt() const -> std::optional<Nonnull<const Statement*>> { return stmt; }
private:
std::optional<Ptr<const Statement>> stmt;
std::optional<Nonnull<const Statement*>> stmt;
};
class While : public Statement {
public:
While(SourceLocation loc, Ptr<const Expression> cond,
Ptr<const Statement> body)
While(SourceLocation loc, Nonnull<const Expression*> cond,
Nonnull<const Statement*> body)
: Statement(Kind::While, loc), cond(cond), body(body) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::While;
}
auto Cond() const -> Ptr<const Expression> { return cond; }
auto Body() const -> Ptr<const Statement> { return body; }
auto Cond() const -> Nonnull<const Expression*> { return cond; }
auto Body() const -> Nonnull<const Statement*> { return body; }
private:
Ptr<const Expression> cond;
Ptr<const Statement> body;
Nonnull<const Expression*> cond;
Nonnull<const Statement*> body;
};
class Break : public Statement {
@@ -226,23 +227,25 @@ class Continue : public Statement {
class Match : public Statement {
public:
Match(
SourceLocation loc, Ptr<const Expression> exp,
std::vector<std::pair<Ptr<const Pattern>, Ptr<const Statement>>> clauses)
SourceLocation loc, Nonnull<const Expression*> exp,
std::vector<std::pair<Nonnull<const Pattern*>, Nonnull<const Statement*>>>
clauses)
: Statement(Kind::Match, loc), exp(exp), clauses(std::move(clauses)) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::Match;
}
auto Exp() const -> Ptr<const Expression> { return exp; }
auto Clauses() const -> const
std::vector<std::pair<Ptr<const Pattern>, Ptr<const Statement>>>& {
auto Exp() const -> Nonnull<const Expression*> { return exp; }
auto Clauses() const -> const std::vector<
std::pair<Nonnull<const Pattern*>, Nonnull<const Statement*>>>& {
return clauses;
}
private:
Ptr<const Expression> exp;
std::vector<std::pair<Ptr<const Pattern>, Ptr<const Statement>>> clauses;
Nonnull<const Expression*> exp;
std::vector<std::pair<Nonnull<const Pattern*>, Nonnull<const Statement*>>>
clauses;
};
// A continuation statement.
@@ -253,7 +256,7 @@ class Match : public Statement {
class Continuation : public Statement {
public:
Continuation(SourceLocation loc, std::string continuation_variable,
Ptr<const Statement> body)
Nonnull<const Statement*> body)
: Statement(Kind::Continuation, loc),
continuation_variable(std::move(continuation_variable)),
body(body) {}
@@ -265,11 +268,11 @@ class Continuation : public Statement {
auto ContinuationVariable() const -> const std::string& {
return continuation_variable;
}
auto Body() const -> Ptr<const Statement> { return body; }
auto Body() const -> Nonnull<const Statement*> { return body; }
private:
std::string continuation_variable;
Ptr<const Statement> body;
Nonnull<const Statement*> body;
};
// A run statement.
@@ -277,17 +280,17 @@ class Continuation : public Statement {
// __run <argument>;
class Run : public Statement {
public:
Run(SourceLocation loc, Ptr<const Expression> argument)
Run(SourceLocation loc, Nonnull<const Expression*> argument)
: Statement(Kind::Run, loc), argument(argument) {}
static auto classof(const Statement* stmt) -> bool {
return stmt->Tag() == Kind::Run;
}
auto Argument() const -> Ptr<const Expression> { return argument; }
auto Argument() const -> Nonnull<const Expression*> { return argument; }
private:
Ptr<const Expression> argument;
Nonnull<const Expression*> argument;
};
// An await statement.