blob: 245f02555efcf95c3baa5e5f33473da0af4a4006 [file] [log] [blame] [edit]
// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/canonical_tables.h"
#include "vm/regexp/regexp.h"
namespace dart {
bool MetadataMapTraits::IsMatch(const Object& a, const Object& b) {
// In the absence of hot reload, this can just be an identity check. With
// reload, some old program elements may be retained by the stack, closures
// or mirrors, which are absent from the new version of the library's
// metadata table. This name-based matching fuzzy maps the old program
// elements to corresponding new elements, preserving the behavior of the old
// metaname+fields scheme.
if (a.IsLibrary() && b.IsLibrary()) {
const String& url_a = String::Handle(Library::Cast(a).url());
const String& url_b = String::Handle(Library::Cast(b).url());
return url_a.Equals(url_b);
} else if (a.IsClass() && b.IsClass()) {
const String& name_a = String::Handle(Class::Cast(a).Name());
const String& name_b = String::Handle(Class::Cast(b).Name());
return name_a.Equals(name_b);
} else if (a.IsFunction() && b.IsFunction()) {
const auto& func_a = Function::Cast(a);
const auto& func_b = Function::Cast(b);
if (func_a.IsNonImplicitClosureFunction() ||
func_b.IsNonImplicitClosureFunction()) {
return a.ptr() == b.ptr();
}
const String& name_a = String::Handle(func_a.name());
const String& name_b = String::Handle(func_b.name());
if (!name_a.Equals(name_b)) {
return false;
}
const Object& owner_a = Object::Handle(Function::Cast(a).Owner());
const Object& owner_b = Object::Handle(Function::Cast(b).Owner());
return IsMatch(owner_a, owner_b);
} else if (a.IsField() && b.IsField()) {
const String& name_a = String::Handle(Field::Cast(a).name());
const String& name_b = String::Handle(Field::Cast(b).name());
if (!name_a.Equals(name_b)) {
return false;
}
const Object& owner_a = Object::Handle(Field::Cast(a).Owner());
const Object& owner_b = Object::Handle(Field::Cast(b).Owner());
return IsMatch(owner_a, owner_b);
} else if (a.IsTypeParameter() && b.IsTypeParameter()) {
if (TypeParameter::Cast(a).index() != TypeParameter::Cast(b).index() ||
TypeParameter::Cast(a).base() != TypeParameter::Cast(b).base()) {
return false;
}
return TypeParameter::Cast(a).parameterized_class_id() ==
TypeParameter::Cast(b).parameterized_class_id();
}
return a.ptr() == b.ptr();
}
uword MetadataMapTraits::Hash(const Object& key) {
if (key.IsLibrary()) {
return String::Hash(Library::Cast(key).url());
} else if (key.IsClass()) {
return String::Hash(Class::Cast(key).Name());
} else if (key.IsFunction()) {
return CombineHashes(String::Hash(Function::Cast(key).name()),
Hash(Object::Handle(Function::Cast(key).Owner())));
} else if (key.IsField()) {
return CombineHashes(String::Hash(Field::Cast(key).name()),
Hash(Object::Handle(Field::Cast(key).Owner())));
} else if (key.IsTypeParameter()) {
return TypeParameter::Cast(key).Hash();
} else if (key.IsNamespace()) {
return Hash(Library::Handle(Namespace::Cast(key).target()));
}
UNREACHABLE();
}
CanonicalInstanceKey::CanonicalInstanceKey(const Instance& key) : key_(key) {
ASSERT(!(key.IsString() || key.IsAbstractType()));
}
bool CanonicalInstanceKey::Matches(const Instance& obj) const {
ASSERT(!(obj.IsString() || obj.IsAbstractType()));
if (key_.CanonicalizeEquals(obj)) {
ASSERT(obj.IsCanonical());
return true;
}
return false;
}
uword CanonicalInstanceKey::Hash() const {
return key_.CanonicalizeHash();
}
bool CanonicalInstanceTraits::IsMatch(const Object& a, const Object& b) {
ASSERT(!(a.IsString() || a.IsAbstractType()));
ASSERT(!(b.IsString() || b.IsAbstractType()));
return a.ptr() == b.ptr();
}
bool CanonicalInstanceTraits::IsMatch(const CanonicalInstanceKey& a,
const Object& b) {
return a.Matches(Instance::Cast(b));
}
uword CanonicalInstanceTraits::Hash(const Object& key) {
ASSERT(!(key.IsString() || key.IsAbstractType()));
ASSERT(key.IsInstance());
return Instance::Cast(key).CanonicalizeHash();
}
uword CanonicalInstanceTraits::Hash(const CanonicalInstanceKey& key) {
return key.Hash();
}
ObjectPtr CanonicalInstanceTraits::NewKey(const CanonicalInstanceKey& obj) {
return obj.key_.ptr();
}
ObjectPtr CanonicalRegExpTraits::NewKey(const RegExpKey& key) {
return RegExpEngine::CreateRegExp(Thread::Current(), key.pattern_,
key.flags_);
}
} // namespace dart