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/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;
};