languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-10-06 14:49:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Remove definitions from Kernel canonical names."

Browse source 
This reverts commit ed77783cd3.

BUG=
R=fschneider@google.com

Review-Url: https://codereview.chromium.org/2782913003 .
This commit is contained in:
Zach Anderson 2017-03-29 11:25:15 -07:00
parent fd6c486760
commit a7d1d99389
8 changed files with 353 additions and 410 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
pkg/kernel/lib/ast.dart
View file

@ -997,7 +997,6 @@ class Procedure extends Member {
bool get isAccessor => isGetter || isSetter;
bool get hasGetter => kind != ProcedureKind.Setter;
bool get hasSetter => kind == ProcedureKind.Setter;
bool get isFactory => kind == ProcedureKind.Factory;
accept(MemberVisitor v) => v.visitProcedure(this);

8
pkg/kernel/lib/canonical_name.dart
View file

@ -30,7 +30,7 @@ import 'ast.dart';
/// "@fields"
/// Qualified name
///
/// Procedure that is not an accessor or factory:
/// Procedure that is not an accessor:
/// Canonical name of enclosing class or library
/// "@methods"
/// Qualified name
@ -45,11 +45,6 @@ import 'ast.dart';
/// "@setters"
/// Qualified name
///
/// Procedure that is a factory:
/// Canonical name of enclosing class
/// "@factories"
/// Qualified name
///
/// Qualified name:
/// if private: URI of library
/// Name text
@ -141,7 +136,6 @@ class CanonicalName {
if (member is Procedure) {
if (member.isGetter) return '@getters';
if (member.isSetter) return '@setters';
if (member.isFactory) return '@factories';
return '@methods';
}
if (member is Field) {

202
runtime/vm/kernel.cc
View file

@ -33,6 +33,24 @@ CanonicalName* CanonicalName::NewRoot() {
}
void CanonicalName::BindTo(LinkedNode* new_target) {
ASSERT(new_target != NULL);
if (definition_ == new_target) return;
ASSERT(definition_ == NULL);
ASSERT(new_target->canonical_name_ == NULL);
definition_ = new_target;
new_target->canonical_name_ = this;
}
void CanonicalName::Unbind() {
if (definition_ == NULL) return;
ASSERT(definition_->canonical_name_ == this);
definition_->canonical_name_ = NULL;
definition_ = NULL;
}
CanonicalName* CanonicalName::AddChild(String* name) {
CanonicalName* child = new CanonicalName();
child->parent_ = this;
@ -42,153 +60,33 @@ CanonicalName* CanonicalName::AddChild(String* name) {
}
bool CanonicalName::IsAdministrative() {
// Administrative names start with '@'.
return (name()->size() > 0) && (name()->buffer()[0] == '@');
Library* CanonicalName::AsLibrary() {
return Library::Cast(definition());
}
bool CanonicalName::IsPrivate() {
// Private names start with '_'.
return (name()->size() > 0) && (name()->buffer()[0] == '_');
Class* CanonicalName::AsClass() {
return Class::Cast(definition());
}
bool CanonicalName::IsRoot() {
// The root is the only canonical name with no parent.
return parent() == NULL;
Member* CanonicalName::AsMember() {
return Member::Cast(definition());
}
bool CanonicalName::IsLibrary() {
// Libraries are the only canonical names with the root as their parent.
return !IsRoot() && parent()->IsRoot();
Field* CanonicalName::AsField() {
return Field::Cast(definition());
}
bool CanonicalName::IsClass() {
// Classes have the library as their parent and are not an administrative
// name starting with @.
return !IsAdministrative() && !IsRoot() && parent()->IsLibrary();
Constructor* CanonicalName::AsConstructor() {
return Constructor::Cast(definition());
}
bool CanonicalName::IsMember() {
return IsConstructor() || IsField() || IsProcedure();
}
// Note the two occurrences of the parameter 'literal'.
#define COMPARE_NAME(canonical_name, literal) \
memcmp((canonical_name)->name()->buffer(), (literal), strlen(literal)) == 0
bool CanonicalName::IsField() {
// Fields with private names have the import URI of the library where they are
// visible as the parent and the string "@fields" as the parent's parent.
// Fields with non-private names have the string "@fields' as the parent.
if (IsRoot()) {
return false;
}
CanonicalName* kind = this->parent();
if (IsPrivate()) {
kind = kind->parent();
}
return COMPARE_NAME(kind, "@fields");
}
bool CanonicalName::IsConstructor() {
// Constructors with private names have the import URI of the library where
// they are visible as the parent and the string "@constructors" as the
// parent's parent. Constructors with non-private names have the string
// "@constructors" as the parent.
if (IsRoot()) {
return false;
}
CanonicalName* kind = this->parent();
if (IsPrivate()) {
kind = kind->parent();
}
return COMPARE_NAME(kind, "@constructors");
}
bool CanonicalName::IsProcedure() {
return IsMethod() || IsGetter() || IsSetter() || IsFactory();
}
bool CanonicalName::IsMethod() {
// Methods with private names have the import URI of the library where they
// are visible as the parent and the string "@methods" as the parent's parent.
// Methods with non-private names have the string "@methods" as the parent.
if (IsRoot()) {
return false;
}
CanonicalName* kind = this->parent();
if (IsPrivate()) {
kind = kind->parent();
}
return COMPARE_NAME(kind, "@methods");
}
bool CanonicalName::IsGetter() {
// Getters with private names have the import URI of the library where they
// are visible as the parent and the string "@getters" as the parent's parent.
// Getters with non-private names have the string "@getters" as the parent.
if (IsRoot()) {
return false;
}
CanonicalName* kind = this->parent();
if (IsPrivate()) {
kind = kind->parent();
}
return COMPARE_NAME(kind, "@getters");
}
bool CanonicalName::IsSetter() {
// Setters with private names have the import URI of the library where they
// are visible as the parent and the string "@setters" as the parent's parent.
// Setters with non-private names have the string "@setters" as the parent.
if (IsRoot()) {
return false;
}
CanonicalName* kind = this->parent();
if (IsPrivate()) {
kind = kind->parent();
}
return COMPARE_NAME(kind, "@setters");
}
bool CanonicalName::IsFactory() {
// Factories with private names have the import URI of the library where they
// are visible as the parent and the string "@factories" as the parent's
// parent. Factories with non-private names have the string "@factories" as
// the parent.
if (IsRoot()) {
return false;
}
CanonicalName* kind = this->parent();
if (IsPrivate()) {
kind = kind->parent();
}
return COMPARE_NAME(kind, "@factories");
}
#undef COMPARE_NAME
CanonicalName* CanonicalName::EnclosingName() {
ASSERT(IsField() || IsConstructor() || IsProcedure());
CanonicalName* enclosing = parent()->parent();
if (IsPrivate()) {
enclosing = enclosing->parent();
}
ASSERT(enclosing->IsLibrary() || enclosing->IsClass());
return enclosing;
Procedure* CanonicalName::AsProcedure() {
return Procedure::Cast(definition());
}
@ -237,6 +135,11 @@ void NormalClass::AcceptClassVisitor(ClassVisitor* visitor) {
}
void NormalClass::AcceptReferenceVisitor(ClassReferenceVisitor* visitor) {
visitor->VisitNormalClassReference(this);
}
void NormalClass::VisitChildren(Visitor* visitor) {
VisitList(&type_parameters(), visitor);
if (super_class() != NULL) visitor->VisitInterfaceType(super_class());
@ -255,6 +158,11 @@ void MixinClass::AcceptClassVisitor(ClassVisitor* visitor) {
}
void MixinClass::AcceptReferenceVisitor(ClassReferenceVisitor* visitor) {
visitor->VisitMixinClassReference(this);
}
void MixinClass::VisitChildren(Visitor* visitor) {
VisitList(&type_parameters(), visitor);
visitor->VisitInterfaceType(first());
@ -280,6 +188,11 @@ void Field::AcceptMemberVisitor(MemberVisitor* visitor) {
}
void Field::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) {
visitor->VisitFieldReference(this);
}
void Field::VisitChildren(Visitor* visitor) {
type()->AcceptDartTypeVisitor(visitor);
visitor->VisitName(name());
@ -295,6 +208,11 @@ void Constructor::AcceptMemberVisitor(MemberVisitor* visitor) {
}
void Constructor::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) {
visitor->VisitConstructorReference(this);
}
void Constructor::VisitChildren(Visitor* visitor) {
visitor->VisitName(name());
visitor->VisitFunctionNode(function());
@ -310,6 +228,11 @@ void Procedure::AcceptMemberVisitor(MemberVisitor* visitor) {
}
void Procedure::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) {
visitor->VisitProcedureReference(this);
}
void Procedure::VisitChildren(Visitor* visitor) {
visitor->VisitName(name());
if (function() != NULL) visitor->VisitFunctionNode(function());
@ -344,6 +267,7 @@ void FieldInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) {
void FieldInitializer::VisitChildren(Visitor* visitor) {
visitor->VisitFieldReference(field());
value()->AcceptExpressionVisitor(visitor);
}
@ -357,6 +281,7 @@ void SuperInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) {
void SuperInitializer::VisitChildren(Visitor* visitor) {
visitor->VisitConstructorReference(target());
visitor->VisitArguments(arguments());
}
@ -371,6 +296,7 @@ void RedirectingInitializer::AcceptInitializerVisitor(
void RedirectingInitializer::VisitChildren(Visitor* visitor) {
visitor->VisitConstructorReference(target());
visitor->VisitArguments(arguments());
}
@ -487,6 +413,7 @@ void DirectPropertyGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
void DirectPropertyGet::VisitChildren(Visitor* visitor) {
receiver()->AcceptExpressionVisitor(visitor);
target()->AcceptReferenceVisitor(visitor);
}
@ -500,6 +427,7 @@ void DirectPropertySet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
void DirectPropertySet::VisitChildren(Visitor* visitor) {
receiver()->AcceptExpressionVisitor(visitor);
target()->AcceptReferenceVisitor(visitor);
value()->AcceptExpressionVisitor(visitor);
}
@ -512,7 +440,9 @@ void StaticGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
}
void StaticGet::VisitChildren(Visitor* visitor) {}
void StaticGet::VisitChildren(Visitor* visitor) {
target()->AcceptReferenceVisitor(visitor);
}
StaticSet::~StaticSet() {}
@ -524,6 +454,7 @@ void StaticSet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
void StaticSet::VisitChildren(Visitor* visitor) {
target()->AcceptReferenceVisitor(visitor);
expression()->AcceptExpressionVisitor(visitor);
}
@ -582,6 +513,7 @@ void DirectMethodInvocation::AcceptExpressionVisitor(
void DirectMethodInvocation::VisitChildren(Visitor* visitor) {
receiver()->AcceptExpressionVisitor(visitor);
visitor->VisitProcedureReference(target());
visitor->VisitArguments(arguments());
}
@ -595,6 +527,7 @@ void StaticInvocation::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
void StaticInvocation::VisitChildren(Visitor* visitor) {
visitor->VisitProcedureReference(procedure());
visitor->VisitArguments(arguments());
}
@ -609,6 +542,7 @@ void ConstructorInvocation::AcceptExpressionVisitor(
void ConstructorInvocation::VisitChildren(Visitor* visitor) {
visitor->VisitConstructorReference(target());
visitor->VisitArguments(arguments());
}
@ -1260,6 +1194,7 @@ void InterfaceType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) {
void InterfaceType::VisitChildren(Visitor* visitor) {
klass()->AcceptReferenceVisitor(visitor);
VisitList(&type_arguments(), visitor);
}
@ -1323,6 +1258,7 @@ void Program::AcceptTreeVisitor(TreeVisitor* visitor) {
void Program::VisitChildren(Visitor* visitor) {
VisitList(&libraries(), visitor);
visitor->VisitProcedureReference(main_method());
}

135
runtime/vm/kernel.h
View file

@ -118,6 +118,8 @@
M(ClassVisitor) \
M(InitializerVisitor) \
M(DartTypeVisitor) \
M(ClassReferenceVisitor) \
M(MemberReferenceVisitor) \
M(TreeVisitor) \
M(Visitor)
@ -368,29 +370,20 @@ class CanonicalName {
String* name() { return name_; }
CanonicalName* parent() { return parent_; }
LinkedNode* definition() { return definition_; }
bool is_referenced() { return is_referenced_; }
void set_referenced(bool referenced) { is_referenced_ = referenced; }
void BindTo(LinkedNode* definition);
void Unbind();
CanonicalName* AddChild(String* name);
bool IsAdministrative();
bool IsPrivate();
bool IsRoot();
bool IsLibrary();
bool IsClass();
bool IsMember();
bool IsField();
bool IsConstructor();
bool IsProcedure();
bool IsMethod();
bool IsGetter();
bool IsSetter();
bool IsFactory();
// For a member (field, constructor, or procedure) return the canonical name
// of the enclosing class or library.
CanonicalName* EnclosingName();
Library* AsLibrary();
Class* AsClass();
Member* AsMember();
Field* AsField();
Constructor* AsConstructor();
Procedure* AsProcedure();
static CanonicalName* NewRoot();
@ -400,6 +393,7 @@ class CanonicalName {
bool is_referenced_;
Ref<CanonicalName> parent_;
Ref<String> name_;
Ref<LinkedNode> definition_;
MallocGrowableArray<CanonicalName*> children_;
DISALLOW_COPY_AND_ASSIGN(CanonicalName);
@ -463,9 +457,9 @@ class LinkedNode : public TreeNode {
protected:
LinkedNode() {}
private:
Ref<CanonicalName> canonical_name_;
private:
friend class CanonicalName;
DISALLOW_COPY_AND_ASSIGN(LinkedNode);
@ -539,6 +533,7 @@ class Class : public LinkedNode {
virtual void AcceptTreeVisitor(TreeVisitor* visitor);
virtual void AcceptClassVisitor(ClassVisitor* visitor) = 0;
virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor) = 0;
Library* parent() { return parent_; }
String* name() { return name_; }
@ -580,6 +575,7 @@ class NormalClass : public Class {
DEFINE_CASTING_OPERATIONS(NormalClass);
virtual void AcceptClassVisitor(ClassVisitor* visitor);
virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
virtual TypeParameterList& type_parameters() { return type_parameters_; }
@ -617,6 +613,7 @@ class MixinClass : public Class {
DEFINE_CASTING_OPERATIONS(MixinClass);
virtual void AcceptClassVisitor(ClassVisitor* visitor);
virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
virtual TypeParameterList& type_parameters() { return type_parameters_; }
@ -657,6 +654,7 @@ class Member : public LinkedNode {
virtual void AcceptTreeVisitor(TreeVisitor* visitor);
virtual void AcceptMemberVisitor(MemberVisitor* visitor) = 0;
virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor) = 0;
TreeNode* parent() { return parent_; }
Name* name() { return name_; }
@ -698,6 +696,7 @@ class Field : public Member {
DEFINE_CASTING_OPERATIONS(Field);
virtual void AcceptMemberVisitor(MemberVisitor* visitor);
virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
@ -737,6 +736,7 @@ class Constructor : public Member {
DEFINE_CASTING_OPERATIONS(Constructor);
virtual void AcceptMemberVisitor(MemberVisitor* visitor);
virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; }
@ -786,6 +786,7 @@ class Procedure : public Member {
DEFINE_CASTING_OPERATIONS(Procedure);
virtual void AcceptMemberVisitor(MemberVisitor* visitor);
virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
ProcedureKind kind() { return kind_; }
@ -859,13 +860,13 @@ class FieldInitializer : public Initializer {
virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* field() { return field_reference_; }
Field* field() { return field_reference_->AsField(); }
Expression* value() { return value_; }
private:
FieldInitializer() {}
Ref<CanonicalName> field_reference_; // Field.
Ref<CanonicalName> field_reference_;
Child<Expression> value_;
DISALLOW_COPY_AND_ASSIGN(FieldInitializer);
@ -883,13 +884,13 @@ class SuperInitializer : public Initializer {
virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* target() { return target_reference_; }
Constructor* target() { return target_reference_->AsConstructor(); }
Arguments* arguments() { return arguments_; }
private:
SuperInitializer() {}
Ref<CanonicalName> target_reference_; // Constructor.
Ref<CanonicalName> target_reference_;
Child<Arguments> arguments_;
DISALLOW_COPY_AND_ASSIGN(SuperInitializer);
@ -907,13 +908,13 @@ class RedirectingInitializer : public Initializer {
virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* target() { return target_reference_; }
Constructor* target() { return target_reference_->AsConstructor(); }
Arguments* arguments() { return arguments_; }
private:
RedirectingInitializer() {}
Ref<CanonicalName> target_reference_; // Constructor.
Ref<CanonicalName> target_reference_;
Child<Arguments> arguments_;
DISALLOW_COPY_AND_ASSIGN(RedirectingInitializer);
@ -1146,13 +1147,13 @@ class DirectPropertyGet : public Expression {
virtual void VisitChildren(Visitor* visitor);
Expression* receiver() { return receiver_; }
CanonicalName* target() { return target_reference_; }
Member* target() { return target_reference_->AsMember(); }
private:
DirectPropertyGet() {}
Child<Expression> receiver_;
Ref<CanonicalName> target_reference_; // Member.
Ref<CanonicalName> target_reference_;
DISALLOW_COPY_AND_ASSIGN(DirectPropertyGet);
};
@ -1170,14 +1171,14 @@ class DirectPropertySet : public Expression {
virtual void VisitChildren(Visitor* visitor);
Expression* receiver() { return receiver_; }
CanonicalName* target() { return target_reference_; }
Member* target() { return target_reference_->AsMember(); }
Expression* value() { return value_; }
private:
DirectPropertySet() {}
Child<Expression> receiver_;
Ref<CanonicalName> target_reference_; // Member.
Ref<CanonicalName> target_reference_;
Child<Expression> value_;
DISALLOW_COPY_AND_ASSIGN(DirectPropertySet);
@ -1195,12 +1196,12 @@ class StaticGet : public Expression {
virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* target() { return target_reference_; }
Member* target() { return target_reference_->AsMember(); }
private:
StaticGet() {}
Ref<CanonicalName> target_reference_; // Member.
Ref<CanonicalName> target_reference_;
DISALLOW_COPY_AND_ASSIGN(StaticGet);
};
@ -1217,13 +1218,13 @@ class StaticSet : public Expression {
virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* target() { return target_reference_; }
Member* target() { return target_reference_->AsMember(); }
Expression* expression() { return expression_; }
private:
StaticSet() {}
Ref<CanonicalName> target_reference_; // Member.
Ref<CanonicalName> target_reference_;
Child<Expression> expression_;
DISALLOW_COPY_AND_ASSIGN(StaticSet);
@ -1323,14 +1324,14 @@ class DirectMethodInvocation : public Expression {
virtual void VisitChildren(Visitor* visitor);
Expression* receiver() { return receiver_; }
CanonicalName* target() { return target_reference_; }
Procedure* target() { return target_reference_->AsProcedure(); }
Arguments* arguments() { return arguments_; }
private:
DirectMethodInvocation() {}
Child<Expression> receiver_;
Ref<CanonicalName> target_reference_; // Procedure.
Ref<CanonicalName> target_reference_;
Child<Arguments> arguments_;
DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation);
@ -1345,14 +1346,14 @@ class StaticInvocation : public Expression {
virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* procedure() { return procedure_reference_; }
Procedure* procedure() { return procedure_reference_->AsProcedure(); }
Arguments* arguments() { return arguments_; }
bool is_const() { return is_const_; }
private:
StaticInvocation() {}
Ref<CanonicalName> procedure_reference_; // Procedure.
Ref<CanonicalName> procedure_reference_;
Child<Arguments> arguments_;
bool is_const_;
@ -1372,14 +1373,14 @@ class ConstructorInvocation : public Expression {
virtual void VisitChildren(Visitor* visitor);
bool is_const() { return is_const_; }
CanonicalName* target() { return target_reference_; }
Constructor* target() { return target_reference_->AsConstructor(); }
Arguments* arguments() { return arguments_; }
private:
ConstructorInvocation() {}
bool is_const_;
Ref<CanonicalName> target_reference_; // Constructor.
Ref<CanonicalName> target_reference_;
Child<Arguments> arguments_;
DISALLOW_COPY_AND_ASSIGN(ConstructorInvocation);
@ -2528,14 +2529,18 @@ class Name : public Node {
virtual void VisitChildren(Visitor* visitor);
String* string() { return string_; }
CanonicalName* library() { return library_reference_; }
Library* library() {
if (library_reference_ == NULL) return NULL;
return library_reference_->AsLibrary();
}
CanonicalName* library_reference() { return library_reference_; }
private:
Name(String* string, CanonicalName* library_reference)
: string_(string), library_reference_(library_reference) {} // NOLINT
Ref<String> string_;
Ref<CanonicalName> library_reference_; // Library.
Ref<CanonicalName> library_reference_;
DISALLOW_COPY_AND_ASSIGN(Name);
};
@ -2628,13 +2633,14 @@ class InterfaceType : public DartType {
virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
virtual void VisitChildren(Visitor* visitor);
CanonicalName* klass() { return class_reference_; }
Class* klass() { return class_reference_->AsClass(); }
CanonicalName* class_reference() { return class_reference_; }
List<DartType>& type_arguments() { return type_arguments_; }
private:
InterfaceType() {}
Ref<CanonicalName> class_reference_; // Class.
Ref<CanonicalName> class_reference_;
List<DartType> type_arguments_;
DISALLOW_COPY_AND_ASSIGN(InterfaceType);
@ -2739,7 +2745,10 @@ class Program : public TreeNode {
StringTable& source_uri_table() { return source_uri_table_; }
SourceTable& source_table() { return source_table_; }
List<Library>& libraries() { return libraries_; }
CanonicalName* main_method() { return main_method_reference_; }
Procedure* main_method() {
if (main_method_reference_ == NULL) return NULL;
return main_method_reference_->AsProcedure();
}
CanonicalName* canonical_name_root() { return canonical_name_root_; }
MallocGrowableArray<MallocGrowableArray<intptr_t>*> valid_token_positions;
MallocGrowableArray<MallocGrowableArray<intptr_t>*> yield_token_positions;
@ -2749,7 +2758,7 @@ class Program : public TreeNode {
Child<CanonicalName> canonical_name_root_;
List<Library> libraries_;
Ref<CanonicalName> main_method_reference_; // Procedure.
Ref<CanonicalName> main_method_reference_;
StringTable string_table_;
StringTable source_uri_table_;
SourceTable source_table_;
@ -3004,6 +3013,37 @@ class DartTypeVisitor {
};
class ClassReferenceVisitor {
public:
virtual ~ClassReferenceVisitor() {}
virtual void VisitDefaultClassReference(Class* node) = 0;
virtual void VisitNormalClassReference(NormalClass* node) {
VisitDefaultClassReference(node);
}
virtual void VisitMixinClassReference(MixinClass* node) {
VisitDefaultClassReference(node);
}
};
class MemberReferenceVisitor {
public:
virtual ~MemberReferenceVisitor() {}
virtual void VisitDefaultMemberReference(Member* node) = 0;
virtual void VisitFieldReference(Field* node) {
VisitDefaultMemberReference(node);
}
virtual void VisitConstructorReference(Constructor* node) {
VisitDefaultMemberReference(node);
}
virtual void VisitProcedureReference(Procedure* node) {
VisitDefaultMemberReference(node);
}
};
class TreeVisitor : public ExpressionVisitor,
public StatementVisitor,
public MemberVisitor,
@ -3043,7 +3083,10 @@ class TreeVisitor : public ExpressionVisitor,
};
class Visitor : public TreeVisitor, public DartTypeVisitor {
class Visitor : public TreeVisitor,
public DartTypeVisitor,
public ClassReferenceVisitor,
public MemberReferenceVisitor {
public:
virtual ~Visitor() {}

30
runtime/vm/kernel_binary.cc
View file

@ -494,6 +494,13 @@ class Reader {
return name;
}
CanonicalName* ReadDefiningCanonicalNameReference(LinkedNode* node_to_link) {
CanonicalName* name = ReadCanonicalNameReference();
ASSERT(name != NULL);
name->BindTo(node_to_link);
return name;
}
intptr_t offset() { return offset_; }
private:
@ -680,9 +687,11 @@ Library* Library::ReadFrom(Reader* reader) {
int flags = reader->ReadFlags();
ASSERT(flags == 0); // external libraries not supported
canonical_name_ = reader->ReadCanonicalNameReference();
CanonicalName* canonical_name =
reader->ReadDefiningCanonicalNameReference(this);
name_ = Reference::ReadStringFrom(reader);
import_uri_ = canonical_name_->name();
import_uri_ = canonical_name->name();
source_uri_index_ = reader->ReadUInt();
reader->set_current_script_id(source_uri_index_);
@ -708,7 +717,7 @@ Library* Library::ReadFrom(Reader* reader) {
Class* Class::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
canonical_name_ = reader->ReadCanonicalNameReference();
reader->ReadDefiningCanonicalNameReference(this);
position_ = reader->ReadPosition(false);
is_abstract_ = reader->ReadBool();
name_ = Reference::ReadStringFrom(reader);
@ -800,7 +809,7 @@ Field* Field::ReadFrom(Reader* reader) {
Tag tag = reader->ReadTag();
ASSERT(tag == kField);
canonical_name_ = reader->ReadCanonicalNameReference();
reader->ReadDefiningCanonicalNameReference(this);
position_ = reader->ReadPosition(false);
end_position_ = reader->ReadPosition(false);
flags_ = reader->ReadFlags();
@ -821,7 +830,7 @@ Constructor* Constructor::ReadFrom(Reader* reader) {
Tag tag = reader->ReadTag();
ASSERT(tag == kConstructor);
canonical_name_ = reader->ReadCanonicalNameReference();
reader->ReadDefiningCanonicalNameReference(this);
VariableScope<ReaderHelper> parameters(reader->helper());
position_ = reader->ReadPosition();
end_position_ = reader->ReadPosition();
@ -839,7 +848,7 @@ Procedure* Procedure::ReadFrom(Reader* reader) {
Tag tag = reader->ReadTag();
ASSERT(tag == kProcedure);
canonical_name_ = reader->ReadCanonicalNameReference();
reader->ReadDefiningCanonicalNameReference(this);
VariableScope<ReaderHelper> parameters(reader->helper());
position_ = reader->ReadPosition(false);
end_position_ = reader->ReadPosition(false);
@ -1881,6 +1890,15 @@ Program* Program::ReadFrom(Reader* reader) {
program->main_method_reference_ = Reference::ReadMemberFrom(reader);
#ifdef DEBUG
for (intptr_t i = 0; i < canonical_names; ++i) {
CanonicalName* name = reader->helper()->GetCanonicalName(i);
if (name->is_referenced() && name->definition() == NULL) {
FATAL("Missing definition for canonical name");
}
}
#endif
return program;
}

31
runtime/vm/kernel_reader.cc
View file

@ -134,8 +134,10 @@ Object& KernelReader::ReadProgram() {
}
if (ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
CanonicalName* main = program_->main_method();
dart::Library& library = LookupLibrary(main->EnclosingName());
Procedure* main = program_->main_method();
Library* kernel_main_library = Library::Cast(main->parent());
dart::Library& library =
LookupLibrary(kernel_main_library->canonical_name());
// Sanity check that we can find the main entrypoint.
Object& main_obj = Object::Handle(
@ -358,8 +360,7 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
ActiveFunctionScope active_function_scope(&active_class_,
kernel_constructor->function());
const dart::String& name =
H.DartConstructorName(kernel_constructor->canonical_name());
const dart::String& name = H.DartConstructorName(kernel_constructor);
Function& function = dart::Function::ZoneHandle(
Z, dart::Function::New(name, RawFunction::kConstructor,
false, // is_static
@ -413,8 +414,7 @@ void KernelReader::ReadProcedure(const dart::Library& library,
ActiveFunctionScope active_function_scope(&active_class_,
kernel_procedure->function());
const dart::String& name =
H.DartProcedureName(kernel_procedure->canonical_name());
const dart::String& name = H.DartProcedureName(kernel_procedure);
bool is_method = kernel_klass != NULL && !kernel_procedure->IsStatic();
bool is_abstract = kernel_procedure->IsAbstract();
bool is_external = kernel_procedure->IsExternal();
@ -428,18 +428,16 @@ void KernelReader::ReadProcedure(const dart::Library& library,
if (!annotation->IsConstructorInvocation()) continue;
ConstructorInvocation* invocation =
ConstructorInvocation::Cast(annotation);
CanonicalName* annotation_class = invocation->target()->EnclosingName();
ASSERT(annotation_class->IsClass());
Class* annotation_class = Class::Cast(invocation->target()->parent());
String* class_name = annotation_class->name();
// Just compare by name, do not generate the annotation class.
int length = sizeof("ExternalName") - 1;
if (class_name->size() != length) continue;
if (memcmp(class_name->buffer(), "ExternalName", length) != 0) continue;
ASSERT(annotation_class->parent()->IsLibrary());
String* library_name = annotation_class->parent()->name();
length = sizeof("dart:_internal") - 1;
length = sizeof("dart._internal") - 1;
if (library_name->size() != length) continue;
if (memcmp(library_name->buffer(), "dart:_internal", length) != 0) {
if (memcmp(library_name->buffer(), "dart._internal", length) != 0) {
continue;
}
@ -495,9 +493,8 @@ void KernelReader::ReadProcedure(const dart::Library& library,
if (kernel_klass == NULL) {
library.AddObject(function, name);
ASSERT(!Object::Handle(
Z, library.LookupObjectAllowPrivate(
H.DartProcedureName(kernel_procedure->canonical_name())))
ASSERT(!Object::Handle(Z, library.LookupObjectAllowPrivate(
H.DartProcedureName(kernel_procedure)))
.IsNull());
}
if (FLAG_enable_mirrors) {
@ -632,8 +629,7 @@ void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
}
}
const dart::String& getter_name =
H.DartGetterName(kernel_field->canonical_name());
const dart::String& getter_name = H.DartGetterName(kernel_field->name());
const Object& script_class =
ClassForScriptAt(klass, kernel_field->source_uri_index());
Function& getter = Function::ZoneHandle(
@ -663,8 +659,7 @@ void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
if (!kernel_field->IsStatic() && !kernel_field->IsFinal()) {
// Only static fields can be const.
ASSERT(!kernel_field->IsConst());
const dart::String& setter_name =
H.DartSetterName(kernel_field->canonical_name());
const dart::String& setter_name = H.DartSetterName(kernel_field->name());
Function& setter = Function::ZoneHandle(
Z, Function::New(setter_name, RawFunction::kImplicitSetter,
false, // is_static

308
runtime/vm/kernel_to_il.cc
View file

@ -277,13 +277,13 @@ ScopeBuildingResult* ScopeBuilder::BuildScopes() {
dart::Class::Handle(zone_, parsed_function_->function().Owner());
Function& outermost_function = Function::Handle(Z);
TreeNode* outermost_node = NULL;
Class* kernel_class = NULL;
Class* kernel_klass = NULL;
DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
&kernel_class);
// Use [klass]/[kernel_class] as active class. Type parameters will get
// resolved via [kernel_class] unless we are nested inside a static factory
&kernel_klass);
// Use [klass]/[kernel_klass] as active class. Type parameters will get
// resolved via [kernel_klass] unless we are nested inside a static factory
// in which case we will use [member].
ActiveClassScope active_class_scope(&active_class_, kernel_class, &klass);
ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
? Member::Cast(outermost_node)
: NULL;
@ -1070,48 +1070,33 @@ dart::String& TranslationHelper::DartSymbol(String* content) const {
const dart::String& TranslationHelper::DartClassName(
CanonicalName* kernel_class) {
ASSERT(kernel_class->IsClass());
dart::String& name = DartString(kernel_class->name());
return ManglePrivateName(kernel_class->parent(), &name);
CanonicalName* kernel_klass) {
dart::String& name = DartString(kernel_klass->name());
return ManglePrivateName(kernel_klass->parent(), &name);
}
const dart::String& TranslationHelper::DartConstructorName(
CanonicalName* constructor) {
ASSERT(constructor->IsConstructor());
return DartFactoryName(constructor);
const dart::String& TranslationHelper::DartConstructorName(Constructor* node) {
Class* klass = Class::Cast(node->parent());
return DartFactoryName(klass, node->name());
}
const dart::String& TranslationHelper::DartProcedureName(
CanonicalName* procedure) {
ASSERT(procedure->IsProcedure());
if (procedure->IsSetter()) {
return DartSetterName(procedure);
} else if (procedure->IsGetter()) {
return DartGetterName(procedure);
} else if (procedure->IsFactory()) {
return DartFactoryName(procedure);
const dart::String& TranslationHelper::DartProcedureName(Procedure* procedure) {
if (procedure->kind() == Procedure::kSetter) {
return DartSetterName(procedure->name());
} else if (procedure->kind() == Procedure::kGetter) {
return DartGetterName(procedure->name());
} else if (procedure->kind() == Procedure::kFactory) {
return DartFactoryName(Class::Cast(procedure->parent()), procedure->name());
} else {
return DartMethodName(procedure);
return DartMethodName(procedure->name());
}
}
const dart::String& TranslationHelper::DartSetterName(CanonicalName* setter) {
return DartSetterName(setter->parent(), setter->name());
}
const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
return DartSetterName(setter_name->library(), setter_name->string());
}
const dart::String& TranslationHelper::DartSetterName(CanonicalName* parent,
String* setter) {
// The names flowing into [setter] are coming from the Kernel file:
const dart::String& TranslationHelper::DartSetterName(Name* kernel_name) {
// The names flowing into [content] are coming from the Kernel file:
// * user-defined setters: `fieldname=`
// * property-set expressions: `fieldname`
//
@ -1119,34 +1104,24 @@ const dart::String& TranslationHelper::DartSetterName(CanonicalName* parent,
//
// => In order to be consistent, we remove the `=` always and adopt the VM
// conventions.
ASSERT(setter->size() > 0);
String* content = kernel_name->string();
ASSERT(content->size() > 0);
intptr_t skip = 0;
if (setter->buffer()[setter->size() - 1] == '=') {
if (content->buffer()[content->size() - 1] == '=') {
skip = 1;
}
dart::String& name = dart::String::ZoneHandle(
Z, dart::String::FromUTF8(setter->buffer(), setter->size() - skip,
Z, dart::String::FromUTF8(content->buffer(), content->size() - skip,
allocation_space_));
ManglePrivateName(parent, &name, false);
ManglePrivateName(kernel_name->library_reference(), &name, false);
name = dart::Field::SetterSymbol(name);
return name;
}
const dart::String& TranslationHelper::DartGetterName(CanonicalName* getter) {
return DartGetterName(getter->parent(), getter->name());
}
const dart::String& TranslationHelper::DartGetterName(Name* getter_name) {
return DartGetterName(getter_name->library(), getter_name->string());
}
const dart::String& TranslationHelper::DartGetterName(CanonicalName* parent,
String* getter) {
dart::String& name = DartString(getter);
ManglePrivateName(parent, &name, false);
const dart::String& TranslationHelper::DartGetterName(Name* kernel_name) {
dart::String& name = DartString(kernel_name->string());
ManglePrivateName(kernel_name->library_reference(), &name, false);
name = dart::Field::GetterSymbol(name);
return name;
}
@ -1154,7 +1129,7 @@ const dart::String& TranslationHelper::DartGetterName(CanonicalName* parent,
const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
dart::String& name = DartString(kernel_name->string());
return ManglePrivateName(kernel_name->library(), &name);
return ManglePrivateName(kernel_name->library_reference(), &name);
}
@ -1167,30 +1142,19 @@ const dart::String& TranslationHelper::DartInitializerName(Name* kernel_name) {
}
const dart::String& TranslationHelper::DartMethodName(CanonicalName* method) {
return DartMethodName(method->parent(), method->name());
const dart::String& TranslationHelper::DartMethodName(Name* kernel_name) {
dart::String& name = DartString(kernel_name->string());
return ManglePrivateName(kernel_name->library_reference(), &name);
}
const dart::String& TranslationHelper::DartMethodName(Name* method_name) {
return DartMethodName(method_name->library(), method_name->string());
}
const dart::String& TranslationHelper::DartMethodName(CanonicalName* parent,
String* method) {
dart::String& name = DartString(method);
return ManglePrivateName(parent, &name);
}
const dart::String& TranslationHelper::DartFactoryName(CanonicalName* factory) {
ASSERT(factory->IsConstructor() || factory->IsFactory());
GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
pieces.Add(DartClassName(factory->EnclosingName()));
pieces.Add(Symbols::Dot());
const dart::String& TranslationHelper::DartFactoryName(Class* klass,
Name* method_name) {
// [DartMethodName] will mangle the name.
pieces.Add(DartMethodName(factory));
GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
pieces.Add(DartClassName(klass->canonical_name()));
pieces.Add(Symbols::Dot());
pieces.Add(DartMethodName(method_name));
return dart::String::ZoneHandle(
Z, dart::Symbols::FromConcatAll(thread_, pieces));
}
@ -1198,10 +1162,6 @@ const dart::String& TranslationHelper::DartFactoryName(CanonicalName* factory) {
dart::RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
CanonicalName* kernel_library) {
// We only use the name and don't rely on having any particular parent. This
// ASSERT is just a sanity check.
ASSERT(kernel_library->IsLibrary() ||
kernel_library->parent()->IsAdministrative());
const dart::String& library_name = DartSymbol(kernel_library->name());
ASSERT(!library_name.IsNull());
dart::RawLibrary* library =
@ -1212,11 +1172,11 @@ dart::RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
dart::RawClass* TranslationHelper::LookupClassByKernelClass(
CanonicalName* kernel_class) {
ASSERT(kernel_class->IsClass());
CanonicalName* kernel_klass) {
dart::RawClass* klass = NULL;
const dart::String& class_name = DartClassName(kernel_class);
CanonicalName* kernel_library = kernel_class->parent();
const dart::String& class_name = DartClassName(kernel_klass);
CanonicalName* kernel_library = kernel_klass->parent();
dart::Library& library =
dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
klass = library.LookupClassAllowPrivate(class_name);
@ -1227,44 +1187,36 @@ dart::RawClass* TranslationHelper::LookupClassByKernelClass(
dart::RawField* TranslationHelper::LookupFieldByKernelField(
CanonicalName* kernel_field) {
ASSERT(kernel_field->IsField());
CanonicalName* enclosing = kernel_field->EnclosingName();
Field* kernel_field) {
TreeNode* node = kernel_field->parent();
dart::Class& klass = dart::Class::Handle(Z);
if (enclosing->IsLibrary()) {
dart::Library& library =
dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
klass = library.toplevel_class();
if (node->IsClass()) {
klass = LookupClassByKernelClass(Class::Cast(node)->canonical_name());
} else {
ASSERT(enclosing->IsClass());
klass = LookupClassByKernelClass(enclosing);
ASSERT(node->IsLibrary());
dart::Library& library = dart::Library::Handle(
Z, LookupLibraryByKernelLibrary(Library::Cast(node)->canonical_name()));
klass = library.toplevel_class();
}
dart::RawField* field =
klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()));
klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()->string()));
ASSERT(field != Object::null());
return field;
}
dart::RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
CanonicalName* procedure) {
Procedure* procedure) {
ASSERT(procedure->IsStatic());
const dart::String& procedure_name = DartProcedureName(procedure);
// The parent is either a library or a class (in which case the procedure is a
// static method).
CanonicalName* enclosing = procedure->EnclosingName();
if (enclosing->IsLibrary()) {
dart::Library& library =
dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
dart::RawFunction* function =
library.LookupFunctionAllowPrivate(procedure_name);
ASSERT(function != Object::null());
return function;
} else {
ASSERT(enclosing->IsClass());
dart::Class& klass =
dart::Class::Handle(Z, LookupClassByKernelClass(enclosing));
TreeNode* parent = procedure->parent();
if (parent->IsClass()) {
dart::Class& klass = dart::Class::Handle(
Z, LookupClassByKernelClass(Class::Cast(parent)->canonical_name()));
dart::RawFunction* raw_function =
klass.LookupFunctionAllowPrivate(procedure_name);
ASSERT(raw_function != Object::null());
@ -1277,23 +1229,31 @@ dart::RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
function = function.RedirectionTarget();
}
return function.raw();
} else {
ASSERT(parent->IsLibrary());
dart::Library& library = dart::Library::Handle(
Z,
LookupLibraryByKernelLibrary(Library::Cast(parent)->canonical_name()));
dart::RawFunction* function =
library.LookupFunctionAllowPrivate(procedure_name);
ASSERT(function != Object::null());
return function;
}
}
dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
CanonicalName* constructor) {
ASSERT(constructor->IsConstructor());
Constructor* constructor) {
Class* kernel_klass = Class::Cast(constructor->parent());
dart::Class& klass = dart::Class::Handle(
Z, LookupClassByKernelClass(constructor->EnclosingName()));
Z, LookupClassByKernelClass(kernel_klass->canonical_name()));
return LookupConstructorByKernelConstructor(klass, constructor);
}
dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
const dart::Class& owner,
CanonicalName* constructor) {
ASSERT(constructor->IsConstructor());
Constructor* constructor) {
dart::RawFunction* function =
owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
ASSERT(function != Object::null());
@ -1346,12 +1306,13 @@ void TranslationHelper::ReportError(const Error& prev_error,
}
dart::String& TranslationHelper::ManglePrivateName(CanonicalName* parent,
dart::String* name_to_modify,
bool symbolize) {
dart::String& TranslationHelper::ManglePrivateName(
CanonicalName* kernel_library,
dart::String* name_to_modify,
bool symbolize) {
if (name_to_modify->Length() >= 1 && name_to_modify->CharAt(0) == '_') {
const dart::Library& library =
dart::Library::Handle(Z, LookupLibraryByKernelLibrary(parent));
dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
*name_to_modify = library.PrivateName(*name_to_modify);
} else if (symbolize) {
*name_to_modify = Symbols::New(thread_, *name_to_modify);
@ -1719,10 +1680,11 @@ void ConstantEvaluator::VisitMethodInvocation(MethodInvocation* node) {
void ConstantEvaluator::VisitStaticGet(StaticGet* node) {
CanonicalName* target = node->target();
if (target->IsField()) {
Member* member = node->target();
if (member->IsField()) {
Field* kernel_field = Field::Cast(member);
const dart::Field& field =
dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
dart::Field::Handle(Z, H.LookupFieldByKernelField(kernel_field));
if (field.StaticValue() == Object::sentinel().raw() ||
field.StaticValue() == Object::transition_sentinel().raw()) {
field.EvaluateInitializer();
@ -1732,17 +1694,19 @@ void ConstantEvaluator::VisitStaticGet(StaticGet* node) {
} else {
result_ = field.StaticValue();
}
} else if (target->IsProcedure()) {
const Function& function =
Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
} else if (member->IsProcedure()) {
Procedure* procedure = Procedure::Cast(member);
const Function& target = Function::ZoneHandle(
Z, H.LookupStaticMethodByKernelProcedure(procedure));
if (target->IsMethod()) {
if (procedure->kind() == Procedure::kMethod) {
ASSERT(procedure->IsStatic());
Function& closure_function =
Function::ZoneHandle(Z, function.ImplicitClosureFunction());
closure_function.set_kernel_function(function.kernel_function());
Function::ZoneHandle(Z, target.ImplicitClosureFunction());
closure_function.set_kernel_function(target.kernel_function());
result_ = closure_function.ImplicitStaticClosure();
result_ = H.Canonicalize(result_);
} else if (target->IsGetter()) {
} else if (procedure->kind() == Procedure::kGetter) {
UNIMPLEMENTED();
} else {
UNIMPLEMENTED();
@ -1850,7 +1814,7 @@ void ConstantEvaluator::VisitNot(Not* node) {
void ConstantEvaluator::VisitPropertyGet(PropertyGet* node) {
const intptr_t kLengthLen = sizeof("length") - 1;
const intptr_t kLengthLen = strlen("length");
String* string = node->name()->string();
if ((string->size() == kLengthLen) &&
@ -2875,11 +2839,11 @@ Fragment FlowGraphBuilder::ThrowNoSuchMethodError() {
dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
CanonicalName* target,
Member* target,
const dart::String& method_name) {
CanonicalName* kernel_class = target->EnclosingName();
dart::Class& klass =
dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
Class* kernel_klass = Class::Cast(target->parent());
dart::Class& klass = dart::Class::Handle(
Z, H.LookupClassByKernelClass(kernel_klass->canonical_name()));
dart::RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
ASSERT(function != Object::null());
@ -3038,14 +3002,14 @@ FlowGraph* FlowGraphBuilder::BuildGraph() {
Function& outermost_function = Function::Handle(Z);
TreeNode* outermost_node = NULL;
Class* kernel_class = NULL;
Class* kernel_klass = NULL;
DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
&kernel_class);
&kernel_klass);
// Mark that we are using [klass]/[kernell_klass] as active class. Resolving
// of type parameters will get resolved via [kernell_klass] unless we are
// nested inside a static factory in which case we will use [member].
ActiveClassScope active_class_scope(&active_class_, kernel_class, &klass);
ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
? Member::Cast(outermost_node)
: NULL;
@ -3162,8 +3126,8 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfFunction(FunctionNode* function,
// TODO(27590): Currently the [VariableDeclaration]s from the
// initializers will be visible inside the entire body of the constructor.
// We should make a separate scope for them.
Class* kernel_class = Class::Cast(constructor->parent());
body += TranslateInitializers(kernel_class, &constructor->initializers());
Class* kernel_klass = Class::Cast(constructor->parent());
body += TranslateInitializers(kernel_klass, &constructor->initializers());
}
// The specification defines the result of `a == b` to be:
@ -3563,8 +3527,8 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfFieldAccessor(
bool is_setter = function.IsImplicitSetterFunction();
bool is_method = !function.IsStaticFunction();
dart::Field& field = dart::Field::ZoneHandle(
Z, H.LookupFieldByKernelField(kernel_field->canonical_name()));
dart::Field& field =
dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
TargetEntryInstr* normal_entry = BuildTargetEntry();
graph_entry_ = new (Z)
@ -4110,7 +4074,7 @@ JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
Fragment FlowGraphBuilder::TranslateInitializers(
Class* kernel_class,
Class* kernel_klass,
List<Initializer>* initializers) {
Fragment instructions;
@ -4118,12 +4082,12 @@ Fragment FlowGraphBuilder::TranslateInitializers(
// class A {
// var x = (expr);
// }
for (intptr_t i = 0; i < kernel_class->fields().length(); i++) {
Field* kernel_field = kernel_class->fields()[i];
for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
Field* kernel_field = kernel_klass->fields()[i];
Expression* init = kernel_field->initializer();
if (!kernel_field->IsStatic() && init != NULL) {
dart::Field& field = dart::Field::ZoneHandle(
Z, H.LookupFieldByKernelField(kernel_field->canonical_name()));
dart::Field& field =
dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
EnterScope(kernel_field);
instructions += LoadLocal(scopes_->this_variable);
@ -4518,8 +4482,8 @@ void DartTypeTranslator::VisitInterfaceType(InterfaceType* node) {
node->type_arguments().raw_array(), node->type_arguments().length());
dart::Object& klass =
dart::Object::Handle(Z, H.LookupClassByKernelClass(node->klass()));
dart::Object& klass = dart::Object::Handle(
Z, H.LookupClassByKernelClass(node->class_reference()));
result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
if (finalize_) {
ASSERT(active_class_->klass != NULL);
@ -4642,15 +4606,16 @@ void FlowGraphBuilder::VisitVariableSet(VariableSet* node) {
void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
CanonicalName* target = node->target();
Member* target = node->target();
if (target->IsField()) {
Field* kernel_field = Field::Cast(target);
const dart::Field& field =
dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
if (field.is_const()) {
fragment_ = Constant(constant_evaluator_.EvaluateExpression(node));
} else {
const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
const dart::String& getter_name = H.DartGetterName(target);
const dart::String& getter_name = H.DartGetterName(kernel_field->name());
const Function& getter =
Function::ZoneHandle(Z, owner.LookupStaticFunction(getter_name));
if (getter.IsNull() || !field.has_initializer()) {
@ -4661,12 +4626,14 @@ void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
}
}
} else {
const Function& function =
Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
Procedure* procedure = Procedure::Cast(target);
const Function& target = Function::ZoneHandle(
Z, H.LookupStaticMethodByKernelProcedure(procedure));
if (target->IsGetter()) {
fragment_ = StaticCall(node->position(), function, 0);
} else if (target->IsMethod()) {
if (procedure->kind() == Procedure::kGetter) {
fragment_ = StaticCall(node->position(), target, 0);
} else if (procedure->kind() == Procedure::kMethod) {
ASSERT(procedure->IsStatic());
fragment_ = Constant(constant_evaluator_.EvaluateExpression(node));
} else {
UNIMPLEMENTED();
@ -4676,10 +4643,11 @@ void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
CanonicalName* target = node->target();
Member* target = node->target();
if (target->IsField()) {
Field* kernel_field = Field::Cast(target);
const dart::Field& field =
dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
Fragment instructions = TranslateExpression(node->expression());
if (NeedsDebugStepCheck(stack_, node->position())) {
@ -4702,9 +4670,10 @@ void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
instructions += PushArgument();
// Invoke the setter function.
const Function& function =
Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
instructions += StaticCall(node->position(), function, 1);
Procedure* procedure = Procedure::Cast(target);
const Function& target = Function::ZoneHandle(
Z, H.LookupStaticMethodByKernelProcedure(procedure));
instructions += StaticCall(node->position(), target, 1);
// Drop the unused result & leave the stored value on the stack.
fragment_ = instructions + Drop();
@ -4738,21 +4707,24 @@ void FlowGraphBuilder::VisitPropertySet(PropertySet* node) {
void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
Function& target = Function::ZoneHandle(Z);
CanonicalName* kernel_name = node->target();
if (kernel_name->IsProcedure()) {
if (kernel_name->IsGetter()) {
target = LookupMethodByMember(kernel_name, H.DartGetterName(kernel_name));
if (node->target()->IsProcedure()) {
Procedure* kernel_procedure = Procedure::Cast(node->target());
Name* kernel_name = kernel_procedure->name();
if (kernel_procedure->kind() == Procedure::kGetter) {
target =
LookupMethodByMember(kernel_procedure, H.DartGetterName(kernel_name));
} else {
target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
target =
LookupMethodByMember(kernel_procedure, H.DartMethodName(kernel_name));
target = target.ImplicitClosureFunction();
ASSERT(!target.IsNull());
fragment_ = BuildImplicitClosureCreation(target);
return;
}
} else {
ASSERT(kernel_name->IsField());
const dart::String& getter_name = H.DartGetterName(kernel_name);
target = LookupMethodByMember(kernel_name, getter_name);
ASSERT(node->target()->IsField());
const dart::String& getter_name = H.DartGetterName(node->target()->name());
target = LookupMethodByMember(node->target(), getter_name);
ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
}
@ -4763,7 +4735,7 @@ void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
void FlowGraphBuilder::VisitDirectPropertySet(DirectPropertySet* node) {
const dart::String& method_name = H.DartSetterName(node->target());
const dart::String& method_name = H.DartSetterName(node->target()->name());
const Function& target = Function::ZoneHandle(
Z, LookupMethodByMember(node->target(), method_name));
ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
@ -4955,8 +4927,10 @@ void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
return;
}
Class* kernel_class = Class::Cast(node->target()->parent());
dart::Class& klass = dart::Class::ZoneHandle(
Z, H.LookupClassByKernelClass(node->target()->EnclosingName()));
Z, H.LookupClassByKernelClass(kernel_class->canonical_name()));
Fragment instructions;

48
runtime/vm/kernel_to_il.h
View file

@ -301,26 +301,16 @@ class TranslationHelper {
const dart::String& DartSymbol(const char* content) const;
dart::String& DartSymbol(String* content) const;
const dart::String& DartClassName(CanonicalName* kernel_class);
const dart::String& DartConstructorName(CanonicalName* constructor);
const dart::String& DartProcedureName(CanonicalName* procedure);
const dart::String& DartSetterName(CanonicalName* setter);
const dart::String& DartSetterName(Name* setter_name);
const dart::String& DartGetterName(CanonicalName* getter);
const dart::String& DartGetterName(Name* getter_name);
const dart::String& DartClassName(CanonicalName* kernel_klass);
const dart::String& DartConstructorName(Constructor* node);
const dart::String& DartProcedureName(Procedure* procedure);
const dart::String& DartSetterName(Name* kernel_name);
const dart::String& DartGetterName(Name* kernel_name);
const dart::String& DartFieldName(Name* kernel_name);
const dart::String& DartInitializerName(Name* kernel_name);
const dart::String& DartMethodName(CanonicalName* method);
const dart::String& DartMethodName(Name* method_name);
const dart::String& DartFactoryName(CanonicalName* factory);
const dart::String& DartMethodName(Name* kernel_name);
const dart::String& DartFactoryName(Class* klass, Name* kernel_name);
const Array& ArgumentNames(List<NamedExpression>* named);
@ -330,12 +320,12 @@ class TranslationHelper {
virtual RawLibrary* LookupLibraryByKernelLibrary(CanonicalName* library);
virtual RawClass* LookupClassByKernelClass(CanonicalName* klass);
RawField* LookupFieldByKernelField(CanonicalName* field);
RawFunction* LookupStaticMethodByKernelProcedure(CanonicalName* procedure);
RawFunction* LookupConstructorByKernelConstructor(CanonicalName* constructor);
RawField* LookupFieldByKernelField(Field* field);
RawFunction* LookupStaticMethodByKernelProcedure(Procedure* procedure);
RawFunction* LookupConstructorByKernelConstructor(Constructor* constructor);
dart::RawFunction* LookupConstructorByKernelConstructor(
const dart::Class& owner,
CanonicalName* constructor);
Constructor* constructor);
dart::Type& GetCanonicalType(const dart::Class& klass);
@ -343,18 +333,12 @@ class TranslationHelper {
void ReportError(const Error& prev_error, const char* format, ...);
private:
// This will mangle [name_to_modify] if necessary and make the result a symbol
// if asked. The result will be avilable in [name_to_modify] and it is also
// returned. If the name is private, the canonical name [parent] will be used
// to get the import URI of the library where the name is visible.
dart::String& ManglePrivateName(CanonicalName* parent,
// This will mangle [kernel_name] (if necessary) and make the result a symbol.
// The result will be avilable in [name_to_modify] and it is also returned.
dart::String& ManglePrivateName(CanonicalName* kernel_library,
dart::String* name_to_modify,
bool symbolize = true);
const dart::String& DartSetterName(CanonicalName* parent, String* setter);
const dart::String& DartGetterName(CanonicalName* parent, String* getter);
const dart::String& DartMethodName(CanonicalName* parent, String* method);
dart::Thread* thread_;
dart::Zone* zone_;
dart::Isolate* isolate_;
@ -833,7 +817,7 @@ class FlowGraphBuilder : public ExpressionVisitor, public StatementVisitor {
Fragment TranslateArguments(Arguments* node, Array* argument_names);
ArgumentArray GetArguments(int count);
Fragment TranslateInitializers(Class* kernel_class,
Fragment TranslateInitializers(Class* kernel_klass,
List<Initializer>* initialiers);
Fragment TranslateStatement(Statement* statement);
@ -960,7 +944,7 @@ class FlowGraphBuilder : public ExpressionVisitor, public StatementVisitor {
bool NeedsDebugStepCheck(Value* value, TokenPosition position);
Fragment DebugStepCheck(TokenPosition position);
dart::RawFunction* LookupMethodByMember(CanonicalName* target,
dart::RawFunction* LookupMethodByMember(Member* target,
const dart::String& method_name);
LocalVariable* MakeTemporary();