#include "Entity/Type.h"
bool Type::equals(const SharedPtr &rhs) const {
// 如果rhs为nullptr, 直接返回false
if (!rhs) {
return false;
}
// 如果比较的两类型ä¸å±žäºŽåŒç±», 直接返回false
if (isBasic() && rhs->isArray() || isArray() && rhs->isBasic()) {
return false;
}
if (SharedPtr basicType = dynPtrCast(rhs)) {
const auto *type = dynamic_cast(this);
return type->equals(basicType);
} else {
SharedPtr arrayType = dynPtrCast(rhs);
const auto *type = dynamic_cast(this);
return type->equals(arrayType);
}
}
// 相åŒç±»åž‹
// 1. 相ç‰çš„类型是相åŒç±»åž‹
// 2. 基础整型和基础浮点型是相åŒç±»åž‹
// 3. 数组与空数组是相åŒç±»åž‹
bool Type::sameAs(const SharedPtr &rhs) const {
// å³æ“作å为空直接返回false
if (!rhs) {
return false;
}
// 相ç‰çš„类型是兼容的
if (equals(rhs)) {
return true;
}
// 整数和浮点数是åŒç±»çš„
if (isNumber() && rhs->isNumber()) {
return true;
}
if (isArray() && rhs->isUnknown()) {
// 1. å·¦æ“作å为数组, å³æ“作å为unknown基础类型, å·¦æ“作å兼容å³æ“作å(å之ä¸æˆç«‹)
// 2. å·¦å³æ“作å都是数组, 且å³æ“作åä¸ºç©ºæ ‘ç»„, å·¦æ“作å深度ä¸å°äºŽå³æ“作å深度, å·¦æ“作å兼容å³æ“作å(å之ä¸æˆç«‹)
if (rhs->isBasic() || rhs->isArray() && asArray()->getDepth() >= rhs->asArray()->getDepth()) {
return true;
}
}
return false;
}
// å·¦æ“作å: å½¢å¼ä¸Šçš„类型(左值的类型(å˜é‡å£°æ˜Žç±»åž‹), 函数形å‚类型)
// å³æ“作å: 实际的类型(å³å€¼çš„类型(å˜é‡èµ‹å€¼ç±»åž‹), 函数实å‚类型)
// 兼容是有方å‘çš„, å·¦æ“作å兼容å³æ“作å并ä¸ä¸€å®šä»£è¡¨å³æ“作å兼容左æ“作å
bool Type::compatibleWith(const SharedPtr &rhs) const {
// å³æ“作å为空直接返回false
if (!rhs) {
return false;
}
// åŒç±»çš„类型是兼容的
if (equals(rhs) || sameAs(rhs)) {
return true;
}
if (isNumberArray() && rhs->isNumberArray()) {
if (asArray()->getDepth() == rhs->asArray()->getDepth()) {
return true;
}
}
return false;
}
BasicType::BasicType(BasicTypeKind kind) : kind(kind) {}
bool BasicType::isBasic() const {
return true;
}
bool BasicType::isBoolean() const {
return kind == BasicTypeKind::Boolean;
}
bool BasicType::isInteger() const {
return kind == BasicTypeKind::Integer;
}
bool BasicType::isFloat() const {
return kind == BasicTypeKind::Float;
}
bool BasicType::isNumber() const {
return kind == BasicTypeKind::Integer || kind == BasicTypeKind::Float;
}
bool BasicType::isString() const {
return kind == BasicTypeKind::String;
}
bool BasicType::isUnknown() const {
return kind == BasicTypeKind::Unknown;
}
bool BasicType::isArray() const {
return false;
}
SharedPtr BasicType::asArray() const {
return nullptr;
}
BasicTypeKind BasicType::getKind() const {
return kind;
}
bool BasicType::equals(const SharedPtr &rhs) const {
return kind == rhs->kind;
}
bool BasicType::isNumberArray() const {
return false;
}
SharedPtr ArrayType::createNDArrayType(const SharedPtr &basicType, size_t depth) {
SharedPtr type = basicType;
for (size_t i = 0; i < depth; ++i) {
type = makeShared(type);
}
return staticPtrCast(type);
}
ArrayType::ArrayType(const SharedPtr &elementType) : elementType(elementType) {
if (elementType->isArray()) {
depth = elementType->asArray()->depth + 1;
}
}
bool ArrayType::isBasic() const {
return false;
}
bool ArrayType::isBoolean() const {
return false;
}
bool ArrayType::isInteger() const {
return false;
}
bool ArrayType::isFloat() const {
return false;
}
bool ArrayType::isNumber() const {
return false;
}
bool ArrayType::isString() const {
return false;
}
bool ArrayType::isUnknown() const {
return getBasicElementType()->isUnknown();
}
bool ArrayType::isArray() const {
return true;
}
SharedPtr ArrayType::asArray() const {
return constPtrCast(staticPtrCast(shared_from_this()));
}
const SharedPtr &ArrayType::getElementType() const {
return elementType;
}
SharedPtr ArrayType::getBasicElementType() const {
if (elementType->isBasic()) {
return elementType;
}
SharedPtr iterType = elementType;
while (iterType->isArray()) {
iterType = iterType->asArray()->elementType;
}
return iterType;
}
bool ArrayType::equals(const SharedPtr &rhs) const {
return elementType->equals(rhs->elementType);
}
size_t ArrayType::getDepth() const {
return depth;
}
bool ArrayType::isNumberArray() const {
if (getBasicElementType()->isNumber()) {
return true;
}
return false;
}