carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-06 08:54:47 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Merge ClassDefinition and ClassDeclaration (#940)

Browse Source
This commit is contained in:
Jon Meow
2021-11-09 15:24:22 -08:00
committed by GitHub
parent 73eea8e47a
commit e8d9b7675b
8 changed files with 34 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/BUILD
-12
View File
@@ -14,17 +14,6 @@ cc_library(
],
)
cc_library(
name = "class_definition",
hdrs = ["class_definition.h"],
deps = [
":member",
":source_location",
"//common:ostream",
"@llvm-project//llvm:Support",
],
)
cc_library(
name = "declaration",
srcs = ["declaration.cpp"],
@@ -32,7 +21,6 @@ cc_library(
"declaration.h",
],
deps = [
":class_definition",
":member",
":pattern",
":source_location",
executable_semantics/ast/class_definition.h
-44
View File
@@ -1,44 +0,0 @@
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#ifndef EXECUTABLE_SEMANTICS_AST_CLASS_DEFINITION_H_
#define EXECUTABLE_SEMANTICS_AST_CLASS_DEFINITION_H_
#include <string>
#include <vector>
#include "executable_semantics/ast/member.h"
#include "executable_semantics/ast/source_location.h"
#include "executable_semantics/ast/static_scope.h"
namespace Carbon {
class StaticScope;
class ClassDefinition {
public:
ClassDefinition(SourceLocation source_loc, std::string name,
std::vector<Nonnull<Member*>> members)
: source_loc_(source_loc),
name_(std::move(name)),
members_(std::move(members)) {}
auto source_loc() const -> SourceLocation { return source_loc_; }
auto name() const -> const std::string& { return name_; }
auto members() const -> llvm::ArrayRef<Nonnull<Member*>> { return members_; }
// Contains class members.
auto static_scope() const -> const StaticScope& { return static_scope_; }
auto static_scope() -> StaticScope& { return static_scope_; }
private:
SourceLocation source_loc_;
std::string name_;
std::vector<Nonnull<Member*>> members_;
StaticScope static_scope_;
};
} // namespace Carbon
#endif // EXECUTABLE_SEMANTICS_AST_CLASS_DEFINITION_H_
executable_semantics/ast/declaration.cpp
+3 -4
View File
@@ -17,10 +17,9 @@ void Declaration::Print(llvm::raw_ostream& out) const {
break;
case Kind::ClassDeclaration: {
const ClassDefinition& class_def =
cast<ClassDeclaration>(*this).definition();
out << "class " << class_def.name() << " {\n";
for (Nonnull<Member*> m : class_def.members()) {
const auto& class_decl = cast<ClassDeclaration>(*this);
out << "class " << class_decl.name() << " {\n";
for (Nonnull<Member*> m : class_decl.members()) {
out << *m;
}
out << "}\n";
executable_semantics/ast/declaration.h
+11 -5
View File
@@ -10,7 +10,6 @@
#include <vector>
#include "common/ostream.h"
#include "executable_semantics/ast/class_definition.h"
#include "executable_semantics/ast/member.h"
#include "executable_semantics/ast/pattern.h"
#include "executable_semantics/ast/source_location.h"
@@ -160,17 +159,24 @@ class ClassDeclaration : public Declaration {
ClassDeclaration(SourceLocation source_loc, std::string name,
std::vector<Nonnull<Member*>> members)
: Declaration(Kind::ClassDeclaration, source_loc),
definition_(source_loc, std::move(name), std::move(members)) {}
name_(std::move(name)),
members_(std::move(members)) {}
static auto classof(const Declaration* decl) -> bool {
return decl->kind() == Kind::ClassDeclaration;
}
auto definition() const -> const ClassDefinition& { return definition_; }
auto definition() -> ClassDefinition& { return definition_; }
auto name() const -> const std::string& { return name_; }
auto members() const -> llvm::ArrayRef<Nonnull<Member*>> { return members_; }
// Contains class members. Scoped variables are in the body.
auto static_scope() const -> const StaticScope& { return static_scope_; }
auto static_scope() -> StaticScope& { return static_scope_; }
private:
ClassDefinition definition_;
std::string name_;
std::vector<Nonnull<Member*>> members_;
StaticScope static_scope_;
};
class ChoiceDeclaration : public Declaration {
executable_semantics/interpreter/interpreter.cpp
+4 -4
View File
@@ -127,10 +127,10 @@ void Interpreter::InitEnv(const Declaration& d, Env* env) {
}
case Declaration::Kind::ClassDeclaration: {
const ClassDefinition& class_def = cast<ClassDeclaration>(d).definition();
const auto& class_decl = cast<ClassDeclaration>(d);
std::vector<NamedValue> fields;
std::vector<NamedValue> methods;
for (Nonnull<const Member*> m : class_def.members()) {
for (Nonnull<const Member*> m : class_decl.members()) {
switch (m->kind()) {
case Member::Kind::FieldMember: {
const BindingPattern& binding = cast<FieldMember>(*m).binding();
@@ -143,9 +143,9 @@ void Interpreter::InitEnv(const Declaration& d, Env* env) {
}
}
auto st = arena_->New<NominalClassType>(
class_def.name(), std::move(fields), std::move(methods));
class_decl.name(), std::move(fields), std::move(methods));
AllocationId a = heap_.AllocateValue(st);
env->Set(class_def.name(), a);
env->Set(class_decl.name(), a);
break;
}
executable_semantics/interpreter/resolve_names.cpp
+4 -4
View File
@@ -141,10 +141,10 @@ void PopulateNamesInDeclaration(Arena* arena, Declaration& declaration,
break;
}
case Declaration::Kind::ClassDeclaration: {
auto& class_def = cast<ClassDeclaration>(declaration).definition();
static_scope.Add(class_def.name(), &declaration);
for (auto* member : class_def.members()) {
PopulateNamesInMember(arena, *member, class_def.static_scope());
auto& class_decl = cast<ClassDeclaration>(declaration);
static_scope.Add(class_decl.name(), &declaration);
for (auto* member : class_decl.members()) {
PopulateNamesInMember(arena, *member, class_decl.static_scope());
}
break;
}
executable_semantics/interpreter/type_checker.cpp
+10 -9
View File
@@ -1088,11 +1088,12 @@ auto TypeChecker::TypeOfFunDef(TypeEnv types, Env values,
ret);
}
auto TypeChecker::TypeOfClassDef(const ClassDefinition* sd, TypeEnv /*types*/,
Env ct_top) -> Nonnull<const Value*> {
auto TypeChecker::TypeOfClassDecl(const ClassDeclaration& class_decl,
TypeEnv /*types*/, Env ct_top)
-> Nonnull<const Value*> {
std::vector<NamedValue> fields;
std::vector<NamedValue> methods;
for (Nonnull<const Member*> m : sd->members()) {
for (Nonnull<const Member*> m : class_decl.members()) {
switch (m->kind()) {
case Member::Kind::FieldMember: {
const BindingPattern& binding = cast<FieldMember>(*m).binding();
@@ -1111,7 +1112,7 @@ auto TypeChecker::TypeOfClassDef(const ClassDefinition* sd, TypeEnv /*types*/,
}
}
}
return arena_->New<NominalClassType>(sd->name(), std::move(fields),
return arena_->New<NominalClassType>(class_decl.name(), std::move(fields),
std::move(methods));
}
@@ -1120,7 +1121,7 @@ static auto GetName(const Declaration& d) -> const std::string& {
case Declaration::Kind::FunctionDeclaration:
return cast<FunctionDeclaration>(d).name();
case Declaration::Kind::ClassDeclaration:
return cast<ClassDeclaration>(d).definition().name();
return cast<ClassDeclaration>(d).name();
case Declaration::Kind::ChoiceDeclaration:
return cast<ChoiceDeclaration>(d).name();
case Declaration::Kind::VariableDeclaration: {
@@ -1192,11 +1193,11 @@ void TypeChecker::TopLevel(Nonnull<Declaration*> d, TypeCheckContext* tops) {
}
case Declaration::Kind::ClassDeclaration: {
const auto& class_def = cast<ClassDeclaration>(*d).definition();
auto st = TypeOfClassDef(&class_def, tops->types, tops->values);
const auto& class_decl = cast<ClassDeclaration>(*d);
auto st = TypeOfClassDecl(class_decl, tops->types, tops->values);
AllocationId a = interpreter_.AllocateValue(st);
tops->values.Set(class_def.name(), a); // Is this obsolete?
tops->types.Set(class_def.name(), st);
tops->values.Set(class_decl.name(), a); // Is this obsolete?
tops->types.Set(class_decl.name(), st);
break;
}
executable_semantics/interpreter/type_checker.h
+2 -2
View File
@@ -132,8 +132,8 @@ class TypeChecker {
auto TypeOfFunDef(TypeEnv types, Env values, FunctionDeclaration* fun_def)
-> Nonnull<const Value*>;
auto TypeOfClassDef(const ClassDefinition* sd, TypeEnv /*types*/, Env ct_top)
-> Nonnull<const Value*>;
auto TypeOfClassDecl(const ClassDeclaration& class_decl, TypeEnv /*types*/,
Env ct_top) -> Nonnull<const Value*>;
auto TopLevel(std::vector<Nonnull<Declaration*>>* fs) -> TypeCheckContext;
void TopLevel(Nonnull<Declaration*> d, TypeCheckContext* tops);