Adding support for associated types.

Author: csyonghe

source/slang/check.cpp

@@ -147,26 +147,64 @@ namespace Slang
         {
             if (baseExpr)
             {
+                RefPtr<Expr> expr;
+                
                 if (baseExpr->type->As<TypeType>())
                 {
-                    auto expr = new StaticMemberExpr();
-                    expr->loc = loc;
-                    expr->BaseExpression = baseExpr;
-                    expr->name = declRef.GetName();
-                    expr->type = GetTypeForDeclRef(declRef);
-                    expr->declRef = declRef;
-                    return expr;
+                    auto sexpr = new StaticMemberExpr();
+                    sexpr->loc = loc;
+                    sexpr->BaseExpression = baseExpr;
+                    sexpr->name = declRef.GetName();
+                    sexpr->type = GetTypeForDeclRef(declRef);
+                    sexpr->declRef = declRef;
+                    expr = sexpr;
                 }
                 else
                 {
-                    auto expr = new MemberExpr();
-                    expr->loc = loc;
-                    expr->BaseExpression = baseExpr;
-                    expr->name = declRef.GetName();
-                    expr->type = GetTypeForDeclRef(declRef);
-                    expr->declRef = declRef;
-                    return expr;
+                    auto sexpr = new MemberExpr();
+                    sexpr->loc = loc;
+                    sexpr->BaseExpression = baseExpr;
+                    sexpr->name = declRef.GetName();
+                    sexpr->type = GetTypeForDeclRef(declRef);
+                    sexpr->declRef = declRef;
+                    expr = sexpr;
+                }
+                if (auto assocTypeDeclRef = declRef.As<AssocTypeDecl>())
+                {
+                    if (auto genConstraintType = baseExpr->type->As<GenericConstraintDeclRefType>())
+                    {
+                        // if this is a reference from a generic parameter, we need to generate a AssocTypeDeclRefType type.
+                        // for example, if we have an expression T.U where T:ISimple, and U is an associated type defined in ISimple.
+                        // then this expression should evaluate to AssocTypeDeclRefType(T, U).
+                        auto assocTypeDeclType = new AssocTypeDeclRefType();
+                        assocTypeDeclType->declRef = assocTypeDeclRef;
+                        assocTypeDeclType->sourceType = genConstraintType->subType;
+                        assocTypeDeclType->setSession(getSession());
+                        expr->type = QualType(getTypeType(assocTypeDeclType));
+                    }
                 }
+                else if (auto funcDeclRef = declRef.As<CallableDecl>())
+                {
+                    if (auto genConstraintType = baseExpr->type->As<GenericConstraintDeclRefType>())
+                    {
+                        // if this is call expression, propagate the source associated type to the result type
+                        auto funcType = expr->type->As<FuncType>();
+                        if (auto assocRsType = funcType->resultType.As<AssocTypeDeclRefType>())
+                        {
+                            RefPtr<FuncType> newFuncType = new FuncType();
+                            newFuncType->paramTypes = funcType->paramTypes;
+                            RefPtr<AssocTypeDeclRefType> newRsType = new AssocTypeDeclRefType();
+                            newRsType->declRef = assocRsType->declRef;
+                            newRsType->sourceType = genConstraintType->subType;
+                            newRsType->setSession(getSession());
+                            newFuncType->resultType = newRsType;
+                            newFuncType->setSession(funcType->getSession());
+                            expr->type = QualType(newFuncType);
+                        }
+                       
+                    }
+                }
+                return expr;
             }
             else
             {
@@ -1878,7 +1916,6 @@ namespace Slang
             VisitFunctionDeclaration(functionNode);
             // TODO: This should really onlye set "checked header"
             functionNode->SetCheckState(DeclCheckState::Checked);
-
             // TODO: should put the checking of the body onto a "work list"
             // to avoid recursion here.
             if (functionNode->Body)
@@ -2309,7 +2346,6 @@ namespace Slang
         {
             if (functionNode->IsChecked(DeclCheckState::CheckedHeader)) return;
             functionNode->SetCheckState(DeclCheckState::CheckingHeader);
-
             this->function = functionNode;
             auto returnType = CheckProperType(functionNode->ReturnType);
             functionNode->ReturnType = returnType;
@@ -4366,7 +4402,7 @@ namespace Slang
 
 
                         callExpr->FunctionExpr = baseExpr;
-                        callExpr->type = QualType(candidate.resultType);
+                        callExpr->type = QualType(candidate.resultType);// QualType(baseExpr->type->As<FuncType>()->resultType);
 
                         // A call may yield an l-value, and we should take a look at the candidate to be sure
                         if(auto subscriptDeclRef = candidate.item.declRef.As<SubscriptDecl>())
@@ -4557,7 +4593,9 @@ namespace Slang
             OverloadCandidate candidate;
             candidate.flavor = OverloadCandidate::Flavor::Func;
             candidate.item = item;
-            candidate.resultType = GetResultType(funcDeclRef);
+            auto baseExpr = ConstructLookupResultExpr(
+                item, context.baseExpr, context.funcLoc);
+            candidate.resultType = baseExpr->type->As<FuncType>()->resultType; // GetResultType(funcDeclRef);
 
             AddOverloadCandidate(context, candidate);
         }
@@ -5717,10 +5755,6 @@ namespace Slang
 
         RefPtr<Expr> visitInvokeExpr(InvokeExpr *expr)
         {
-            if (auto appExpr = expr->FunctionExpr->As<GenericAppExpr>())
-                if (auto varExpr = appExpr->FunctionExpr->As<VarExpr>())
-                    if (varExpr->name->text == "test")
-                        printf("break");
             // check the base expression first
             expr->FunctionExpr = CheckExpr(expr->FunctionExpr);
 
@@ -6453,7 +6487,7 @@ namespace Slang
             // When we access a constraint or an inheritance decl (as a member),
             // we are conceptually performing a "cast" to the given super-type,
             // with the declaration showing that such a cast is legal.
-            auto type = GetSup(constraintDeclRef);
+            auto type = new GenericConstraintDeclRefType(session, GetSub(constraintDeclRef), GetSup(constraintDeclRef));
             return QualType(type);
         }
         else if (auto funcDeclRef = declRef.As<CallableDecl>())
@@ -6463,7 +6497,8 @@ namespace Slang
         }
         else if (auto assocTypeDeclRef = declRef.As<AssocTypeDecl>())
         {
-            auto type = DeclRefType::Create(session, assocTypeDeclRef);
+            auto type = new AssocTypeDeclRefType(assocTypeDeclRef);
+            type->setSession(session);
             *outTypeResult = type;
             return QualType(getTypeType(type));
         }

source/slang/emit.cpp

@@ -1054,7 +1054,11 @@ struct EmitVisitor
 
     void visitAssocTypeDeclRefType(AssocTypeDeclRefType* /*type*/, TypeEmitArg const& /*arg*/)
     {
-        SLANG_UNREACHABLE("visitAssocTypeDeclRefType in EmitVisitor");
+        //SLANG_UNREACHABLE("visitAssocTypeDeclRefType in EmitVisitor");
+    }
+    void visitGenericConstraintDeclRefType(GenericConstraintDeclRefType* /*type*/, TypeEmitArg const& /*arg*/)
+    {
+        //SLANG_UNREACHABLE("visitGenericConstraintDeclRefType in EmitVisitor");
     }
 
     void visitBasicExpressionType(BasicExpressionType* basicType, TypeEmitArg const& arg)

source/slang/ir-insts.h

@@ -346,10 +346,9 @@ struct IRBuilder
     IRValue* getBoolValue(bool value);
     IRValue* getIntValue(IRType* type, IRIntegerValue value);
     IRValue* getFloatValue(IRType* type, IRFloatingPointValue value);
-
     IRValue* getDeclRefVal(
         DeclRefBase const&  declRef);
-
+    IRValue* getTypeVal(IRType* type); // create an IR value that represents a type
     IRValue* emitSpecializeInst(
         IRType*     type,
         IRValue*    genericVal,

source/slang/ir.cpp

@@ -562,6 +562,16 @@ namespace Slang
         return irValue;
     }
 
+    IRValue * IRBuilder::getTypeVal(IRType * type)
+    {
+        auto irValue = createValue<IRDeclRef>(
+            this,
+            kIROp_TypeType,
+            nullptr);
+        irValue->type = type;
+        return irValue;
+    }
+
     IRValue* IRBuilder::emitSpecializeInst(
         Type*       type,
         IRValue*    genericVal,
@@ -3061,7 +3071,12 @@ namespace Slang
                 return builder->getDeclRefVal(declRef);
             }
             break;
-
+        case kIROp_TypeType:
+            {
+                IRValue* od = (IRValue*)originalValue;
+                return builder->getTypeVal(od->type);
+            }
+            break;
         default:
             SLANG_UNEXPECTED("no value registered for IR value");
             return nullptr;

source/slang/lower-to-ir.cpp

@@ -2062,6 +2062,11 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
         SLANG_UNIMPLEMENTED_X("decl catch-all");
     }
 
+    LoweredValInfo visitTypeDefDecl(TypeDefDecl * decl)
+    {
+        return LoweredValInfo::simple(context->irBuilder->getTypeVal(decl->type.type));
+    }
+
     LoweredValInfo visitGenericTypeParamDecl(GenericTypeParamDecl* decl)
     {
         return LoweredValInfo();
@@ -2307,7 +2312,8 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
 
         // For now, we don't have an IR-level representation
         // for the type itself.
-        return LoweredValInfo();
+        return LoweredValInfo::simple(context->irBuilder->getTypeVal(DeclRefType::Create(context->getSession(), 
+            DeclRef<Decl>(decl, nullptr))));
     }
 
 

source/slang/lower.cpp

@@ -779,6 +779,13 @@ struct LoweringVisitor
             translateDeclRef(DeclRef<Decl>(type->declRef)).As<TypeDefDecl>());
     }
 
+    RefPtr<Type> visitGenericConstraintDeclRefType(GenericConstraintDeclRefType* type)
+    {
+        // not supported by lowering
+        SLANG_UNREACHABLE("visitGenericConstraintDeclRefType in LowerVisitor");
+        return nullptr;
+    }
+
     RefPtr<Type> visitAssocTypeDeclRefType(AssocTypeDeclRefType* type)
     {
         // not supported by lowering

source/slang/mangle.cpp

@@ -117,6 +117,10 @@ namespace Slang
         {
             emitQualifiedName(context, declRefType->declRef);
         }
+        else if (auto assocTypeDeclRefType = dynamic_cast<AssocTypeDeclRefType*>(type))
+        {
+            emitQualifiedName(context, assocTypeDeclRefType->declRef);
+        }
         else
         {
             SLANG_UNEXPECTED("unimplemented case in mangling");

source/slang/syntax.cpp

@@ -959,15 +959,60 @@ void Type::accept(IValVisitor* visitor, void* extra)
 
     RefPtr<Val> AssocTypeDeclRefType::SubstituteImpl(Substitutions* subst, int* ioDiff)
     {
-        auto parentType = this->GetDeclRef().GetParent().SubstituteImpl(subst, ioDiff);
-        if (auto aggDeclRef = parentType.As<AggTypeDecl>())
+        if (!sourceType)
+            return this;
+        if (auto parentDeclRefType = sourceType->As<DeclRefType>())
         {
-            Decl* targetTypeDecl = nullptr;
-            if (aggDeclRef.getDecl()->memberDictionary.TryGetValue(this->GetDeclRef().decl->getName(), targetTypeDecl))
+            auto parentDeclRef = parentDeclRefType->declRef;
+            DeclRef<AggTypeDecl> newParentDeclRef = parentDeclRef.As<AggTypeDecl>();
+            // search for a substitution that might apply to us
+            for (auto s = subst; s; s = s->outer.Ptr())
             {
-                return DeclRefType::Create(this->session, DeclRef<Decl>(targetTypeDecl, parentType.substitutions));
+                // the generic decl associated with the substitution list must be
+                // the generic decl that declared this parameter
+                auto genericDecl = s->genericDecl;
+                if (genericDecl != parentDeclRef.getDecl()->ParentDecl)
+                    continue;
+                int index = 0;
+                for (auto m : genericDecl->Members)
+                {
+                    if (m.Ptr() == parentDeclRef.getDecl())
+                    {
+                        // We've found it, so return the corresponding specialization argument
+                        (*ioDiff)++;
+                        if (auto declRef = s->args[index].As<DeclRefType>())
+                        {
+                            newParentDeclRef = (*declRef).declRef.As<AggTypeDecl>();
+                            goto searchEnd;
+                        }
+                    }
+                    else if (auto typeParam = m.As<GenericTypeParamDecl>())
+                    {
+                        index++;
+                    }
+                    else if (auto valParam = m.As<GenericValueParamDecl>())
+                    {
+                        index++;
+                    }
+                    else
+                    {
+                    }
+                }
+            }
+        searchEnd:
+            if (newParentDeclRef)
+            {
+                Decl* targetTypeDecl = nullptr;
+                if (newParentDeclRef.getDecl()->memberDictionary.TryGetValue(this->GetDeclRef().decl->getName(), targetTypeDecl))
+                {
+                    if (auto typeDefDecl = targetTypeDecl->As<TypeDefDecl>())
+                        return GetType(DeclRef<TypeDefDecl>(typeDefDecl, subst));
+                    else
+                        return DeclRefType::Create(this->getSession(), DeclRef<Decl>(targetTypeDecl, subst));
+                }
             }
         }
+       
         return this;
     }
 
@@ -981,6 +1026,69 @@ void Type::accept(IValVisitor* visitor, void* extra)
         return this;
     }
 
+    // GenericConstraintDeclRefType
+
+    String GenericConstraintDeclRefType::ToString()
+    {
+        // TODO: what is appropriate here?
+        return "<GenericConstraintType>";
+    }
+
+    bool GenericConstraintDeclRefType::EqualsImpl(Type * type)
+    {
+        if (auto other = type->As<GenericConstraintDeclRefType>())
+        {
+            return supType->Equals(other->supType) && subType->Equals(other->subType);
+        }
+        return false;
+    }
+
+    RefPtr<Val> GenericConstraintDeclRefType::SubstituteImpl(Substitutions* subst, int* ioDiff)
+    {
+        auto genParamDecl = subType.As<DeclRefType>()->declRef.As<GenericTypeParamDecl>();
+        // search for a substitution that might apply to us
+        for (auto s = subst; s; s = s->outer.Ptr())
+        {
+            // the generic decl associated with the substitution list must be
+            // the generic decl that declared this parameter
+            auto genericDecl = s->genericDecl;
+            if (genericDecl != genParamDecl.getDecl()->ParentDecl)
+                continue;
+            int index = 0;
+            for (auto m : genericDecl->Members)
+            {
+                if (m.Ptr() == genParamDecl.getDecl())
+                {
+                    // We've found it, so return the corresponding specialization argument
+                    (*ioDiff)++;
+                    return s->args[index];
+                }
+                else if (auto typeParam = m.As<GenericTypeParamDecl>())
+                {
+                    index++;
+                }
+                else if (auto valParam = m.As<GenericValueParamDecl>())
+                {
+                    index++;
+                }
+                else
+                {
+                }
+            }
+        }
+        return this;
+    }
+
+    int GenericConstraintDeclRefType::GetHashCode()
+    {
+        return combineHash(subType.GetHashCode(), supType.GetHashCode());
+    }
+
+    Type* GenericConstraintDeclRefType::CreateCanonicalType()
+    {
+        return this;
+    }
+
     // ArithmeticExpressionType
 
     // VectorExpressionType