https://github.com/shader-slang/slang
Tip revision: 01efe34dbef2be952298075abd8d36cc67ac9f4e authored by Yong He on 04 March 2024, 21:14:21 UTC
Add `IGlobalSession::getSessionDescDigest`. (#3669)
Add `IGlobalSession::getSessionDescDigest`. (#3669)
Tip revision: 01efe34
slang-check-decl.cpp
// slang-check-decl.cpp
#include "slang-ast-modifier.h"
#include "slang-ast-support-types.h"
#include "slang-check-impl.h"
// This file constaints the semantic checking logic and
// related queries for declarations.
//
// Because declarations are the top-level construct
// of the AST (in turn containing all the statements,
// types, and expressions), the declaration-checking
// logic also orchestrates the overall flow and how
// and when things get checked.
#include "slang-lookup.h"
#include "slang-syntax.h"
#include "slang-ast-synthesis.h"
#include "slang-ast-reflect.h"
#include "slang-ast-iterator.h"
#include <limits>
namespace Slang
{
/// Visitor to transition declarations to `DeclCheckState::CheckedModifiers`
struct SemanticsDeclModifiersVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclModifiersVisitor>
{
SemanticsDeclModifiersVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDeclGroup(DeclGroup*) {}
void visitDecl(Decl* decl)
{
checkModifiers(decl);
}
void visitStructDecl(StructDecl* structDecl);
};
struct SemanticsDeclScopeWiringVisitor : public SemanticsDeclVisitorBase, public DeclVisitor<SemanticsDeclScopeWiringVisitor>
{
SemanticsDeclScopeWiringVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDeclGroup(DeclGroup*) {}
void visitDecl(Decl*) {}
void visitUsingDecl(UsingDecl* decl);
void visitImplementingDecl(ImplementingDecl* decl);
void visitNamespaceDecl(NamespaceDecl* decl);
};
struct SemanticsDeclAttributesVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclAttributesVisitor>
{
SemanticsDeclAttributesVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void visitStructDecl(StructDecl* structDecl);
void visitFunctionDeclBase(FunctionDeclBase* decl);
void checkForwardDerivativeOfAttribute(FunctionDeclBase* funcDecl, ForwardDerivativeOfAttribute* attr);
void checkBackwardDerivativeOfAttribute(FunctionDeclBase* funcDecl, BackwardDerivativeOfAttribute* attr);
void checkPrimalSubstituteOfAttribute(FunctionDeclBase* funcDecl, PrimalSubstituteOfAttribute* attr);
};
struct SemanticsDeclHeaderVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclHeaderVisitor>
{
SemanticsDeclHeaderVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void checkDerivativeMemberAttribute(VarDeclBase* varDecl, DerivativeMemberAttribute* attr);
void checkExtensionExternVarAttribute(VarDeclBase* varDecl, ExtensionExternVarModifier* m);
void checkMeshOutputDecl(VarDeclBase* varDecl);
void checkVarDeclCommon(VarDeclBase* varDecl);
void visitVarDecl(VarDecl* varDecl)
{
checkVarDeclCommon(varDecl);
}
void visitGlobalGenericValueParamDecl(GlobalGenericValueParamDecl* decl)
{
checkVarDeclCommon(decl);
}
void visitImportDecl(ImportDecl* decl);
void visitIncludeDecl(IncludeDecl* decl);
void visitGenericTypeParamDecl(GenericTypeParamDecl* decl);
void visitGenericValueParamDecl(GenericValueParamDecl* decl);
void visitGenericTypeConstraintDecl(GenericTypeConstraintDecl* decl);
void visitGenericDecl(GenericDecl* genericDecl);
void visitTypeDefDecl(TypeDefDecl* decl);
void visitGlobalGenericParamDecl(GlobalGenericParamDecl* decl);
void visitAssocTypeDecl(AssocTypeDecl* decl);
void checkCallableDeclCommon(CallableDecl* decl);
void visitFuncDecl(FuncDecl* funcDecl);
void visitParamDecl(ParamDecl* paramDecl);
void visitConstructorDecl(ConstructorDecl* decl);
void visitAbstractStorageDeclCommon(ContainerDecl* decl);
void visitSubscriptDecl(SubscriptDecl* decl);
void visitPropertyDecl(PropertyDecl* decl);
void visitStructDecl(StructDecl* decl);
void visitClassDecl(ClassDecl* decl);
/// Get the type of the storage accessed by an accessor.
///
/// The type of storage is determined by the parent declaration.
Type* _getAccessorStorageType(AccessorDecl* decl);
/// Perform checks common to all types of accessors.
void _visitAccessorDeclCommon(AccessorDecl* decl);
void visitAccessorDecl(AccessorDecl* decl);
void visitSetterDecl(SetterDecl* decl);
void cloneModifiers(Decl* dest, Decl* src);
void setFuncTypeIntoRequirementDecl(CallableDecl* decl, FuncType* funcType);
};
struct SemanticsDeclRedeclarationVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclRedeclarationVisitor>
{
SemanticsDeclRedeclarationVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
#define CASE(TYPE) void visit##TYPE(TYPE* decl) { checkForRedeclaration(decl); }
CASE(EnumCaseDecl)
CASE(FuncDecl)
CASE(VarDeclBase)
CASE(SimpleTypeDecl)
CASE(AggTypeDecl)
#undef CASE
};
struct SemanticsDeclBasesVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclBasesVisitor>
{
SemanticsDeclBasesVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void visitInheritanceDecl(InheritanceDecl* inheritanceDecl);
void visitThisTypeConstraintDecl(ThisTypeConstraintDecl* thisTypeConstraintDecl);
/// Validate that `decl` isn't illegally inheriting from a type in another module.
///
/// This call checks a single `inheritanceDecl` to make sure that it either
/// * names a base type from the same module as `decl`, or
/// * names a type that allows cross-module inheritance
void _validateCrossModuleInheritance(
AggTypeDeclBase* decl,
InheritanceDecl* inheritanceDecl);
void visitInterfaceDecl(InterfaceDecl* decl);
void visitStructDecl(StructDecl* decl);
void visitClassDecl(ClassDecl* decl);
void visitEnumDecl(EnumDecl* decl);
/// Validate that the target type of an extension `decl` is valid.
void _validateExtensionDeclTargetType(ExtensionDecl* decl);
void visitExtensionDecl(ExtensionDecl* decl);
};
struct SemanticsDeclTypeResolutionVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclTypeResolutionVisitor>
{
SemanticsDeclTypeResolutionVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void visitTypeExp(TypeExp& exp)
{
exp.type = resolveType(exp.type);
}
void visitVarDeclBase(VarDeclBase* varDecl)
{
visitTypeExp(varDecl->type);
}
void visitGenericTypeConstraintDecl(GenericTypeConstraintDecl* decl)
{
visitTypeExp(decl->sup);
}
void visitTypeDefDecl(TypeDefDecl* decl)
{
visitTypeExp(decl->type);
}
void visitGenericTypeParamDecl(GenericTypeParamDecl* paramDecl)
{
visitTypeExp(paramDecl->initType);
}
void visitInheritanceDecl(InheritanceDecl* inheritanceDecl)
{
visitTypeExp(inheritanceDecl->base);
}
void visitCallableDecl(CallableDecl* decl)
{
for (auto paramDecl : decl->getMembersOfType<ParamDecl>())
visitTypeExp(paramDecl->type);
visitTypeExp(decl->returnType);
visitTypeExp(decl->errorType);
}
void visitPropertyDecl(PropertyDecl* decl)
{
visitTypeExp(decl->type);
}
};
struct SemanticsDeclBodyVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclBodyVisitor>
{
SemanticsDeclBodyVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void checkVarDeclCommon(VarDeclBase* varDecl);
void visitVarDecl(VarDecl* varDecl)
{
checkVarDeclCommon(varDecl);
}
void visitGenericValueParamDecl(GenericValueParamDecl* genValDecl)
{
checkVarDeclCommon(genValDecl);
}
void visitGlobalGenericValueParamDecl(GlobalGenericValueParamDecl* decl)
{
checkVarDeclCommon(decl);
}
void visitEnumCaseDecl(EnumCaseDecl* decl);
void visitEnumDecl(EnumDecl* decl);
void visitFunctionDeclBase(FunctionDeclBase* funcDecl);
void visitParamDecl(ParamDecl* paramDecl);
void visitAggTypeDecl(AggTypeDecl* aggTypeDecl);
};
template<typename VisitorType>
struct SemanticsDeclReferenceVisitor
: public SemanticsDeclVisitorBase
, public StmtVisitor<VisitorType>
, public ExprVisitor<VisitorType>
, public ValVisitor<VisitorType>
, public DeclVisitor<VisitorType>
{
SemanticsDeclReferenceVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
List<SourceLoc> sourceLocStack;
struct PushSourceLocRAII
{
List<SourceLoc>& stack;
bool shouldPop = false;
PushSourceLocRAII(List<SourceLoc>& sourceLocStack, SourceLoc loc)
: stack(sourceLocStack)
{
if (loc.isValid())
{
stack.add(loc);
shouldPop = true;
}
}
~PushSourceLocRAII()
{
if (shouldPop)
{
stack.removeLast();
}
}
};
virtual void processReferencedDecl(Decl* decl) = 0;
void dispatchIfNotNull(Stmt* stmt)
{
if (!stmt)
return;
PushSourceLocRAII sourceLocRAII(sourceLocStack, stmt->loc);
return StmtVisitor<VisitorType>::dispatch(stmt);
}
void dispatchIfNotNull(Expr* expr)
{
if (!expr)
return;
PushSourceLocRAII sourceLocRAII(sourceLocStack, expr->loc);
return ExprVisitor<VisitorType>::dispatch(expr);
}
void dispatchIfNotNull(Val* val)
{
if (!val)
return;
return ValVisitor<VisitorType>::dispatch(val);
}
void dispatchIfNotNull(DeclBase* val)
{
if (!val)
return;
return DeclVisitor<VisitorType>::dispatch(val);
}
// Expr Visitor
void visitExpr(Expr*) { }
void visitIndexExpr(IndexExpr* subscriptExpr)
{
for (auto arg : subscriptExpr->indexExprs)
dispatchIfNotNull(arg);
dispatchIfNotNull(subscriptExpr->baseExpression);
}
void visitParenExpr(ParenExpr* expr)
{
dispatchIfNotNull(expr->base);
}
void visitAssignExpr(AssignExpr* expr)
{
dispatchIfNotNull(expr->left);
dispatchIfNotNull(expr->right);
}
void visitGenericAppExpr(GenericAppExpr* genericAppExpr)
{
dispatchIfNotNull(genericAppExpr->functionExpr);
for (auto arg : genericAppExpr->arguments)
dispatchIfNotNull(arg);
}
void visitSharedTypeExpr(SharedTypeExpr* expr) { dispatchIfNotNull(expr->base.exp); }
void visitInvokeExpr(InvokeExpr* expr)
{
dispatchIfNotNull(expr->functionExpr);
for (auto arg : expr->arguments)
dispatchIfNotNull(arg);
}
void visitTypeCastExpr(TypeCastExpr* expr)
{
dispatchIfNotNull(expr->functionExpr);
for (auto arg : expr->arguments)
dispatchIfNotNull(arg);
}
void visitDerefExpr(DerefExpr* expr) { dispatchIfNotNull(expr->base); }
void visitMatrixSwizzleExpr(MatrixSwizzleExpr* expr)
{
dispatchIfNotNull(expr->base);
}
void visitSwizzleExpr(SwizzleExpr* expr)
{
dispatchIfNotNull(expr->base);
}
void visitOverloadedExpr(OverloadedExpr*)
{
return;
}
void visitOverloadedExpr2(OverloadedExpr2*)
{
return;
}
void visitAggTypeCtorExpr(AggTypeCtorExpr*)
{
return;
}
void visitCastToSuperTypeExpr(CastToSuperTypeExpr* expr)
{
dispatchIfNotNull(expr->valueArg);
}
void visitModifierCastExpr(ModifierCastExpr* expr) { dispatchIfNotNull(expr->valueArg); }
void visitLetExpr(LetExpr* expr)
{
dispatchIfNotNull(expr->body);
}
void visitExtractExistentialValueExpr(ExtractExistentialValueExpr* expr)
{
dispatchIfNotNull(expr->declRef.declRefBase);
}
void visitDeclRefExpr(DeclRefExpr* expr)
{
dispatchIfNotNull(expr->type.type);
dispatchIfNotNull(expr->declRef.declRefBase);
}
void visitStaticMemberExpr(StaticMemberExpr* expr)
{
dispatchIfNotNull(expr->declRef.declRefBase);
}
void visitInitializerListExpr(InitializerListExpr* expr)
{
for (auto arg : expr->args)
{
dispatchIfNotNull(arg);
}
}
void visitThisExpr(ThisExpr*)
{
return;
}
void visitThisTypeExpr(ThisTypeExpr*) { return; }
void visitAndTypeExpr(AndTypeExpr* expr)
{
dispatchIfNotNull(expr->left.type);
dispatchIfNotNull(expr->right.type);
}
void visitPointerTypeExpr(PointerTypeExpr* expr)
{
dispatchIfNotNull(expr->base.type);
}
void visitAsTypeExpr(AsTypeExpr* expr)
{
dispatchIfNotNull(expr->value);
dispatchIfNotNull(expr->witnessArg);
}
void visitIsTypeExpr(IsTypeExpr* expr)
{
dispatchIfNotNull(expr->value);
dispatchIfNotNull(expr->witnessArg);
}
void visitMakeOptionalExpr(MakeOptionalExpr* expr)
{
dispatchIfNotNull(expr->value);
dispatchIfNotNull(expr->typeExpr);
}
void visitPartiallyAppliedGenericExpr(PartiallyAppliedGenericExpr*)
{
return;
}
void visitSPIRVAsmExpr(SPIRVAsmExpr*)
{
return;
}
void visitModifiedTypeExpr(ModifiedTypeExpr* expr) { dispatchIfNotNull(expr->base.type); }
void visitFuncTypeExpr(FuncTypeExpr* expr)
{
for (const auto& t : expr->parameters)
{
dispatchIfNotNull(t.type);
}
dispatchIfNotNull(expr->result.type);
}
void visitTupleTypeExpr(TupleTypeExpr* expr)
{
for (auto t : expr->members)
{
dispatchIfNotNull(t.type);
}
}
void visitTryExpr(TryExpr* expr) { dispatchIfNotNull(expr->base); }
void visitHigherOrderInvokeExpr(HigherOrderInvokeExpr* expr)
{
dispatchIfNotNull(expr->baseFunction);
}
void visitTreatAsDifferentiableExpr(TreatAsDifferentiableExpr* expr)
{
dispatchIfNotNull(expr->innerExpr);
}
// Stmt Visitor
void visitDeclStmt(DeclStmt* stmt)
{
dispatchIfNotNull(stmt->decl);
}
void visitBlockStmt(BlockStmt* stmt)
{
dispatchIfNotNull(stmt->body);
}
void visitSeqStmt(SeqStmt* seqStmt)
{
for (auto stmt : seqStmt->stmts)
dispatchIfNotNull(stmt);
}
void visitLabelStmt(LabelStmt* stmt)
{
dispatchIfNotNull(stmt->innerStmt);
}
void visitBreakStmt(BreakStmt*) { return; }
void visitContinueStmt(ContinueStmt*) { return; }
void visitDoWhileStmt(DoWhileStmt* stmt)
{
dispatchIfNotNull(stmt->predicate);
dispatchIfNotNull(stmt->statement);
}
void visitForStmt(ForStmt* stmt)
{
dispatchIfNotNull(stmt->initialStatement);
dispatchIfNotNull(stmt->predicateExpression);
dispatchIfNotNull(stmt->sideEffectExpression);
dispatchIfNotNull(stmt->statement);
}
void visitCompileTimeForStmt(CompileTimeForStmt* stmt)
{
dispatchIfNotNull(stmt->rangeBeginExpr);
dispatchIfNotNull(stmt->rangeEndExpr);
dispatchIfNotNull(stmt->body);
}
void visitSwitchStmt(SwitchStmt* stmt)
{
dispatchIfNotNull(stmt->condition);
dispatchIfNotNull(stmt->body);
}
void visitCaseStmt(CaseStmt* stmt) { dispatchIfNotNull(stmt->expr); }
void visitTargetSwitchStmt(TargetSwitchStmt* stmt)
{
for (auto targetCase : stmt->targetCases)
dispatchIfNotNull(targetCase);
}
void visitTargetCaseStmt(TargetCaseStmt* stmt)
{
dispatchIfNotNull(stmt->body);
}
void visitIntrinsicAsmStmt(IntrinsicAsmStmt*) { return; }
void visitDefaultStmt(DefaultStmt*) { return; }
void visitIfStmt(IfStmt* stmt)
{
dispatchIfNotNull(stmt->predicate);
dispatchIfNotNull(stmt->positiveStatement);
dispatchIfNotNull(stmt->negativeStatement);
}
void visitUnparsedStmt(UnparsedStmt*) { return; }
void visitEmptyStmt(EmptyStmt*) { return; }
void visitDiscardStmt(DiscardStmt*) { return; }
void visitReturnStmt(ReturnStmt* stmt) { dispatchIfNotNull(stmt->expression); }
void visitWhileStmt(WhileStmt* stmt)
{
dispatchIfNotNull(stmt->predicate);
dispatchIfNotNull(stmt->statement);
}
void visitGpuForeachStmt(GpuForeachStmt*) { return; }
void visitExpressionStmt(ExpressionStmt* stmt)
{
dispatchIfNotNull(stmt->expression);
}
// Val Visitor
void visitDirectDeclRef(DirectDeclRef* declRef)
{
// If we have already visited, return.
// Otherwise add it to visited set.
if (!visitedVals.add(declRef))
return;
processReferencedDecl(declRef->getDecl());
}
void visitVal(Val* val)
{
// If we have already visited, return.
// Otherwise add it to visited set.
if (!visitedVals.add(val))
return;
for (Index i = 0; i < val->getOperandCount(); i++)
{
auto& operand = val->m_operands[i];
switch (operand.kind)
{
case ValNodeOperandKind::ValNode:
dispatchIfNotNull(val->getOperand(i));
break;
default:
break;
}
}
return;
}
HashSet<Val*> visitedVals;
// Decl visitor
void visitDeclBase(DeclBase*)
{}
void visitContainerDecl(ContainerDecl* decl)
{
for (auto m : decl->members)
{
dispatchIfNotNull(m);
}
}
void visitFunctionDeclBase(FunctionDeclBase* decl)
{
visitContainerDecl(decl);
dispatchIfNotNull(decl->body);
}
void visitVarDeclBase(VarDeclBase* varDecl)
{
dispatchIfNotNull(varDecl->type.type);
dispatchIfNotNull(varDecl->initExpr);
}
};
struct SemanticsDeclCapabilityVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclCapabilityVisitor>
{
CapabilitySet m_anyPlatfromCapabilitySet;
SemanticsDeclCapabilityVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
CapabilitySet& getAnyPlatformCapabilitySet()
{
if (m_anyPlatfromCapabilitySet.isEmpty())
{
m_anyPlatfromCapabilitySet = CapabilitySet(CapabilityName::any_target);
}
return m_anyPlatfromCapabilitySet;
}
CapabilitySet getDeclaredCapabilitySet(Decl* decl);
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void checkVarDeclCommon(VarDeclBase* varDecl);
void visitAggTypeDeclBase(AggTypeDeclBase* decl);
void visitNamespaceDeclBase(NamespaceDeclBase* decl);
void visitVarDecl(VarDecl* varDecl)
{
checkVarDeclCommon(varDecl);
}
void visitParamDecl(ParamDecl* paramDecl)
{
checkVarDeclCommon(paramDecl);
}
void visitFunctionDeclBase(FunctionDeclBase* funcDecl);
void visitInheritanceDecl(InheritanceDecl* inheritanceDecl);
void diagnoseUndeclaredCapability(Decl* decl, const DiagnosticInfo& diagnosticInfo, const CapabilityConjunctionSet* failedAvailableSet);
};
/// Should the given `decl` nested in `parentDecl` be treated as a static rather than instance declaration?
bool isEffectivelyStatic(
Decl* decl,
ContainerDecl* parentDecl)
{
// Things at the global scope are always "members" of their module.
//
if(as<NamespaceDeclBase>(parentDecl))
return false;
if (as<FileDecl>(parentDecl))
return false;
// Anything explicitly marked `static` and not at module scope
// counts as a static rather than instance declaration.
//
if(decl->hasModifier<HLSLStaticModifier>())
return true;
// Next we need to deal with cases where a declaration is
// effectively `static` even if the language doesn't make
// the user say so. Most languages make the default assumption
// that nested types are `static` even if they don't say
// so (Java is an exception here, perhaps due to some
// influence from the Scandanavian OOP tradition of Beta/gbeta).
//
if(as<AggTypeDecl>(decl))
return true;
if(as<SimpleTypeDecl>(decl))
return true;
// Initializer/constructor declarations are effectively `static`
// in Slang. They behave like functions that return an instance
// of the enclosing type, rather than as functions that are
// called on a pre-existing value.
//
if(as<ConstructorDecl>(decl))
return true;
// Things nested inside functions may have dependencies
// on values from the enclosing scope, but this needs to
// be dealt with via "capture" so they are also effectively
// `static`
//
if(as<FunctionDeclBase>(parentDecl))
return true;
// Type constraint declarations are used in member-reference
// context as a form of casting operation, so we treat them
// as if they are instance members. This is a bit of a hack,
// but it achieves the result we want until we have an
// explicit representation of up-cast operations in the
// AST.
//
if(as<TypeConstraintDecl>(decl))
return false;
return false;
}
bool isEffectivelyStatic(
Decl* decl)
{
// For the purposes of an ordinary declaration, when determining if
// it is static or per-instance, the "parent" declaration we really
// care about is the next outer non-generic declaration.
//
// TODO: This idiom of getting the "next outer non-generic declaration"
// comes up just enough that we should probably have a convenience
// function for it.
auto parentDecl = decl->parentDecl;
if(auto genericDecl = as<GenericDecl>(parentDecl))
parentDecl = genericDecl->parentDecl;
return isEffectivelyStatic(decl, parentDecl);
}
bool isGlobalDecl(Decl* decl)
{
if (!decl)
return false;
auto parentDecl = decl->parentDecl;
if (auto genericDecl = as<GenericDecl>(parentDecl))
parentDecl = genericDecl->parentDecl;
return as<NamespaceDeclBase>(parentDecl) != nullptr || as<FileDecl>(parentDecl) != nullptr;
}
bool isUnsafeForceInlineFunc(FunctionDeclBase* funcDecl)
{
return funcDecl->hasModifier<UnsafeForceInlineEarlyAttribute>();
}
/// Is `decl` a global shader parameter declaration?
bool isGlobalShaderParameter(VarDeclBase* decl)
{
// If it's an *actual* global it is not a global shader parameter
if (decl->hasModifier<ActualGlobalModifier>()) { return false; }
// A global shader parameter must be declared at global or namespace
// scope, so that it has a single definition across the module.
//
if(!isGlobalDecl(decl)) return false;
// A global variable marked `static` indicates a traditional
// global variable (albeit one that is implicitly local to
// the translation unit)
//
if(decl->hasModifier<HLSLStaticModifier>()) return false;
// While not normally allowed, out variables are not constant
// parameters, this can happen for example in GLSL mode
if(decl->hasModifier<OutModifier>()) return false;
if(decl->hasModifier<InModifier>()) return false;
// The `groupshared` modifier indicates that a variable cannot
// be a shader parameters, but is instead transient storage
// allocated for the duration of a thread-group's execution.
//
if(decl->hasModifier<HLSLGroupSharedModifier>()) return false;
return true;
}
[[maybe_unused]]
static bool _isUncheckedLocalVar(const Decl* decl)
{
auto checkStateExt = decl->checkState;
auto isUnchecked = checkStateExt.getState() == DeclCheckState::Unchecked || checkStateExt.isBeingChecked();
return isUnchecked && isLocalVar(decl);
}
// Get the type to use when referencing a declaration
QualType getTypeForDeclRef(
ASTBuilder* astBuilder,
SemanticsVisitor* sema,
DiagnosticSink* sink,
DeclRef<Decl> declRef,
Type** outTypeResult,
SourceLoc loc)
{
if( sema )
{
// If this is a local variable which hasn't been checked yet then
// it's probably a declare-after-use which has incorrectly got
// through declref resolution.
SLANG_ASSERT(!_isUncheckedLocalVar(declRef.getDecl()));
// Once we've ruled out the case of referencing a local declaration
// before it has been checked, we will go ahead and ensure that
// semantic checking has been performed on the chosen declaration,
// at least up to the point where we can query its type.
//
sema->ensureDecl(declRef, DeclCheckState::CanUseTypeOfValueDecl);
}
// We need to insert an appropriate type for the expression, based on
// what we found.
if (auto varDeclRef = declRef.as<VarDeclBase>())
{
QualType qualType;
qualType.type = getType(astBuilder, varDeclRef);
bool isLValue = true;
if(varDeclRef.getDecl()->findModifier<ConstModifier>())
isLValue = false;
// Global-scope shader parameters should not be writable,
// since they are effectively program inputs.
//
// TODO: We could eventually treat a mutable global shader
// parameter as a shorthand for an immutable parameter and
// a global variable that gets initialized from that parameter,
// but in order to do so we'd need to support global variables
// with resource types better in the back-end.
//
if(isGlobalShaderParameter(varDeclRef.getDecl()))
isLValue = false;
// Variables declared with `let` are always immutable.
if(varDeclRef.is<LetDecl>())
isLValue = false;
// Generic value parameters are always immutable
if(varDeclRef.is<GenericValueParamDecl>())
isLValue = false;
// Function parameters declared in the "modern" style
// are immutable unless they have an `out` or `inout` modifier.
if(varDeclRef.is<ModernParamDecl>())
{
// Note: the `inout` modifier AST class inherits from
// the class for the `out` modifier so that we can
// make simple checks like this.
//
if( !varDeclRef.getDecl()->hasModifier<OutModifier>() )
{
isLValue = false;
}
}
qualType.isLeftValue = isLValue;
return qualType;
}
else if( auto propertyDeclRef = declRef.as<PropertyDecl>() )
{
// Access to a declared `property` is similar to
// access to a variable/field, except that it
// is mediated through accessors (getters, seters, etc.).
QualType qualType;
qualType.type = getType(astBuilder, propertyDeclRef);
bool isLValue = false;
// If the property has any declared accessors that
// can be used to set the property, then the resulting
// expression behaves as an l-value.
//
if(propertyDeclRef.getDecl()->getMembersOfType<SetterDecl>().isNonEmpty())
isLValue = true;
if(propertyDeclRef.getDecl()->getMembersOfType<RefAccessorDecl>().isNonEmpty())
isLValue = true;
qualType.isLeftValue = isLValue;
return qualType;
}
else if( auto enumCaseDeclRef = declRef.as<EnumCaseDecl>() )
{
sema->ensureDecl(declRef.declRefBase, DeclCheckState::DefinitionChecked);
QualType qualType;
qualType.type = getType(astBuilder, enumCaseDeclRef);
qualType.isLeftValue = false;
return qualType;
}
else if (auto typeAliasDeclRef = declRef.as<TypeDefDecl>())
{
auto type = getNamedType(astBuilder, typeAliasDeclRef);
*outTypeResult = type;
return QualType(astBuilder->getTypeType(type));
}
else if (auto aggTypeDeclRef = declRef.as<AggTypeDecl>())
{
auto type = DeclRefType::create(astBuilder, aggTypeDeclRef);
*outTypeResult = type;
return QualType(astBuilder->getTypeType(type));
}
else if (auto simpleTypeDeclRef = declRef.as<SimpleTypeDecl>())
{
auto type = DeclRefType::create(astBuilder, simpleTypeDeclRef);
*outTypeResult = type;
return QualType(astBuilder->getTypeType(type));
}
else if (auto genericDeclRef = declRef.as<GenericDecl>())
{
auto type = getGenericDeclRefType(astBuilder, genericDeclRef);
*outTypeResult = type;
return QualType(astBuilder->getTypeType(type));
}
else if (auto funcDeclRef = declRef.as<CallableDecl>())
{
auto type = getFuncType(astBuilder, funcDeclRef);
return QualType(type);
}
else if (auto constraintDeclRef = declRef.as<TypeConstraintDecl>())
{
// 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(astBuilder, constraintDeclRef);
return QualType(type);
}
else if( auto namespaceDeclRef = declRef.as<NamespaceDeclBase>())
{
auto type = getNamespaceType(astBuilder, namespaceDeclRef);
return QualType(type);
}
if( sink )
{
// The compiler is trying to form a reference to a declaration
// that doesn't appear to be usable as an expression or type.
//
// In practice, this arises when user code has an undefined-identifier
// error, but the name that was undefined in context also matches
// a contextual keyword. Rather than confuse the user with the
// details of contextual keywords in the compiler, we will diagnose
// this as an undefined identifier.
//
// TODO: This code could break if we ever go down this path with
// an identifier that doesn't have a name.
//
sink->diagnose(loc, Diagnostics::undefinedIdentifier2, declRef.getName());
}
return QualType(astBuilder->getErrorType());
}
QualType getTypeForDeclRef(
ASTBuilder* astBuilder,
DeclRef<Decl> declRef,
SourceLoc loc)
{
Type* typeResult = nullptr;
return getTypeForDeclRef(astBuilder, nullptr, nullptr, declRef, &typeResult, loc);
}
DeclRef<ExtensionDecl> applyExtensionToType(
SemanticsVisitor* semantics,
ExtensionDecl* extDecl,
Type* type)
{
if(!semantics)
return DeclRef<ExtensionDecl>();
return semantics->applyExtensionToType(extDecl, type);
}
bool SemanticsVisitor::isDeclUsableAsStaticMember(
Decl* decl)
{
if (m_allowStaticReferenceToNonStaticMember)
return true;
if(auto genericDecl = as<GenericDecl>(decl))
decl = genericDecl->inner;
if(decl->hasModifier<HLSLStaticModifier>())
return true;
if(as<ConstructorDecl>(decl))
return true;
if(as<EnumCaseDecl>(decl))
return true;
if(as<AggTypeDeclBase>(decl))
return true;
if(as<SimpleTypeDecl>(decl))
return true;
if(as<TypeConstraintDecl>(decl))
return true;
return false;
}
bool SemanticsVisitor::isUsableAsStaticMember(
LookupResultItem const& item)
{
if (m_allowStaticReferenceToNonStaticMember)
return true;
// There's a bit of a gotcha here, because a lookup result
// item might include "breadcrumbs" that indicate more steps
// along the lookup path. As a result it isn't always
// valid to just check whether the final decl is usable
// as a static member, because it might not even be a
// member of the thing we are trying to work with.
//
Decl* decl = item.declRef.getDecl();
for(auto bb = item.breadcrumbs; bb; bb = bb->next)
{
switch(bb->kind)
{
// In case lookup went through a `__transparent` member,
// we are interested in the static-ness of that transparent
// member, and *not* the static-ness of whatever was inside
// of it.
//
// TODO: This would need some work if we ever had
// transparent *type* members.
//
case LookupResultItem::Breadcrumb::Kind::Member:
decl = bb->declRef.getDecl();
break;
// TODO: Are there any other cases that need special-case
// handling here?
default:
break;
}
}
// Okay, we've found the declaration we should actually
// be checking, so lets validate that.
return isDeclUsableAsStaticMember(decl);
}
/// Dispatch an appropriate visitor to check `decl` up to state `state`
///
/// The current state of `decl` must be `state-1`.
/// This call does *not* handle updating the state of `decl`; the
/// caller takes responsibility for doing so.
///
static void _dispatchDeclCheckingVisitor(Decl* decl, DeclCheckState state, SemanticsContext const& shared);
// Make sure a declaration has been checked, so we can refer to it.
// Note that this may lead to us recursively invoking checking,
// so this may not be the best way to handle things.
void SemanticsVisitor::ensureDecl(Decl* decl, DeclCheckState state, SemanticsContext* baseContext)
{
// If the `decl` has already been checked up to or beyond `state`
// then there is nothing for us to do.
//
if (decl->isChecked(state)) return;
// Is the declaration already being checked, somewhere up the
// call stack from us?
//
if(decl->checkState.isBeingChecked())
{
// We tried to reference the same declaration while checking it!
//
// TODO: we should ideally be tracking a "chain" of declarations
// being checked on the stack, so that we can report the full
// chain that leads from this declaration back to itself.
//
getSink()->diagnose(decl, Diagnostics::cyclicReference, decl);
return;
}
// If we should skip the checking, return now.
// A common case to skip checking is for the function bodies when we are in
// the language server. In that case we only care about the function bodies in a
// specific module and can skip checking the reference modules until they
// are being opened/edited later.
if (shouldSkipChecking(decl, state))
{
decl->setCheckState(state);
return;
}
// Set the flag that indicates we are checking this declaration,
// so that the cycle check above will catch us before we go
// into any infinite loops.
//
decl->checkState.setIsBeingChecked(true);
// Our task is to bring the `decl` up to `state` which may be
// one or more steps ahead of where it currently is. We can
// invoke a visitor designed to bring a declaration from state
// N to state N+1, and in general we might need multiple such
// passes to get `decl` to where we need it.
//
// The coding of this loop is somewhat defensive to deal
// with special cases that will be described along the way.
//
auto outerScope = getScope(decl);
for(;;)
{
// The first thing is to check what state the decl is
// currently in at the start of this loop iteration,
// and to bail out if it has been checked up to
// (or beyond) our target state.
//
auto currentState = decl->checkState.getState();
if(currentState >= state)
break;
// Because our visitors are only designed to go from state
// N to N+1 in general, we will aspire to transition to
// a state that is one greater than `currentState`.
//
auto nextState = DeclCheckState(Int(currentState) + 1);
// We now dispatch an appropriate visitor based on `nextState`.
//
// Note that we always dispatch the visitor in a "fresh" semantic-checking
// context, so that the state at the point where a declaration is *referenced*
// cannot affect the state in which the declaration is *checked*.
//
SemanticsContext subContext = baseContext ? SemanticsContext(*baseContext) : SemanticsContext(getShared());
if (outerScope)
subContext = subContext.withOuterScope(outerScope);
_dispatchDeclCheckingVisitor(decl, nextState, subContext);
// In the common case, the visitor will have done the necessary
// checking, but will *not* have updated the `checkState` on
// `decl`. In that case we will do the update here, to save
// us the complication of having to deal with state update in
// every single visitor method.
//
// However, sometimes a visitor *will* want to manually update
// the state of a declaration, and it may actually update it
// *past* the `nextState` we asked for (or even past the
// eventual target `state`). In those cases we don't want to
// accidentally set the state of `decl` to something lower
// than what has actually been checked, so we test for
// such cases here.
//
if(nextState > decl->checkState.getState())
{
decl->setCheckState(nextState);
}
}
// Once we are done here, the state of `decl` should have
// been upgraded to (at least) `state`.
//
SLANG_ASSERT(decl->isChecked(state));
// Now that we are done checking `decl` we need to restore
// its "is being checked" flag so that we don't generate
// errors the next time somebody calls `ensureDecl()` on it.
//
decl->checkState.setIsBeingChecked(false);
}
/// Recursively ensure the tree of declarations under `decl` is in `state`.
///
/// This function does *not* handle declarations nested in function bodies
/// because those cannot be meaningfully checked outside of the context
/// of their surrounding statement(s).
///
static void _ensureAllDeclsRec(
SemanticsDeclVisitorBase* visitor,
Decl* decl,
DeclCheckState state)
{
// Ensure `decl` itself first.
visitor->ensureDecl(decl, state);
// If `decl` is a container, then we want to ensure its children.
if(auto containerDecl = as<ContainerDecl>(decl))
{
// NOTE! We purposefully do not iterate with the for(auto childDecl : containerDecl->members) here,
// because the visitor may add to `members` whilst iteration takes place, invalidating the iterator
// and likely a crash.
//
// Accessing the members via index side steps the issue.
const auto& members = containerDecl->members;
for(Index i = 0; i < members.getCount(); ++i)
{
Decl* childDecl = members[i];
// As an exception, if any of the child is a `ScopeDecl`,
// then that indicates that it represents a scope for local
// declarations under a statement (e.g., in a function body),
// and we don't want to check such local declarations here.
//
if(as<ScopeDecl>(childDecl))
continue;
_ensureAllDeclsRec(visitor, childDecl, state);
}
}
// Note: the "inner" declaration of a `GenericDecl` is currently
// not exposed as one of its children (despite a `GenericDecl`
// being a `ContainerDecl`), so we need to handle the inner
// declaration of a generic as another case here.
//
if(auto genericDecl = as<GenericDecl>(decl))
{
_ensureAllDeclsRec(visitor, genericDecl->inner, state);
}
}
bool isUnsizedArrayType(Type* type)
{
// Not an array?
auto arrayType = as<ArrayExpressionType>(type);
if (!arrayType) return false;
// Explicit element count given?
return arrayType->isUnsized();
}
bool SemanticsVisitor::shouldSkipChecking(Decl* decl, DeclCheckState state)
{
if (state < DeclCheckState::DefinitionChecked)
return false;
// If we are in language server, we should skip checking all the function bodies
// except for the module or function that the user cared about.
// This optimization helps reduce the response time.
if (!getLinkage()->isInLanguageServer())
{
return false;
}
if (auto funcDecl = as<FunctionDeclBase>(decl))
{
auto& assistInfo = getLinkage()->contentAssistInfo;
// If this func is not defined in the primary module, skip checking its body.
auto moduleDecl = getModuleDecl(decl);
if (moduleDecl && moduleDecl->getName() != assistInfo.primaryModuleName)
return true;
if (funcDecl->body)
{
auto humaneLoc = getLinkage()->getSourceManager()->getHumaneLoc(
decl->loc, SourceLocType::Actual);
if (humaneLoc.pathInfo.foundPath != assistInfo.primaryModulePath)
{
return true;
}
if (assistInfo.checkingMode == ContentAssistCheckingMode::Completion)
{
// For completion requests, we skip all funtion bodies except for the one
// that the current cursor is in.
auto startingLine = humaneLoc.line;
for (auto modifier : funcDecl->modifiers)
{
auto modifierLoc = getLinkage()->getSourceManager()->getHumaneLoc(
modifier->loc, SourceLocType::Actual);
if (modifierLoc.line < startingLine)
startingLine = modifierLoc.line;
}
auto closingLoc = getLinkage()->getSourceManager()->getHumaneLoc(
funcDecl->closingSourceLoc, SourceLocType::Actual);
if (assistInfo.cursorLine < startingLine ||
assistInfo.cursorLine > closingLoc.line)
return true;
}
}
}
return false;
}
void SemanticsVisitor::_validateCircularVarDefinition(VarDeclBase* varDecl)
{
// The easiest way to test if the declaration is circular is to
// validate it as a constant.
//
// TODO: The logic here will only apply for `static const` declarations
// of integer type, given that our constant folding currently only
// applies to such types. A more robust fix would involve a truly
// recursive walk of the AST declarations, and an even *more* robust
// fix would wait until after IR linking to detect and diagnose circularity
// in case it crosses module boundaries.
//
//
if(!isScalarIntegerType(varDecl->type))
return;
tryConstantFoldDeclRef(DeclRef<VarDeclBase>(varDecl), nullptr);
}
void SemanticsDeclModifiersVisitor::visitStructDecl(StructDecl* structDecl)
{
checkModifiers(structDecl);
// Replace any bitfield member with a property, do this here before
// name lookup to avoid the original var decl being referenced
for(auto& m : structDecl->members)
{
const auto bfm = m->findModifier<BitFieldModifier>();
if(!bfm)
continue;
auto property = m_astBuilder->create<PropertyDecl>();
property->modifiers = m->modifiers;
property->type = as<VarDecl>(m)->type;
property->loc = m->loc;
property->nameAndLoc = m->getNameAndLoc();
property->parentDecl = structDecl;
property->ownedScope = m_astBuilder->create<Scope>();
property->ownedScope->containerDecl = property;
property->ownedScope->parent = getScope(structDecl);
m = property;
const auto get = m_astBuilder->create<GetterDecl>();
get->ownedScope = m_astBuilder->create<Scope>();
get->ownedScope->containerDecl = get;
get->ownedScope->parent = getScope(property);
property->addMember(get);
const auto set = m_astBuilder->create<SetterDecl>();
addModifier(set, m_astBuilder->create<MutatingAttribute>());
set->ownedScope = m_astBuilder->create<Scope>();
set->ownedScope->containerDecl = set;
set->ownedScope->parent = getScope(property);
property->addMember(set);
structDecl->invalidateMemberDictionary();
}
structDecl->buildMemberDictionary();
}
void SemanticsDeclHeaderVisitor::checkDerivativeMemberAttribute(
VarDeclBase* varDecl, DerivativeMemberAttribute* derivativeMemberAttr)
{
auto memberType = checkProperType(getLinkage(), varDecl->type, getSink());
auto diffType = getDifferentialType(m_astBuilder, memberType, varDecl->loc);
if (as<ErrorType>(diffType))
{
getSink()->diagnose(derivativeMemberAttr, Diagnostics::typeIsNotDifferentiable, memberType);
}
auto thisType = calcThisType(makeDeclRef(varDecl->parentDecl));
if (!thisType)
{
getSink()->diagnose(
derivativeMemberAttr,
Diagnostics::
derivativeMemberAttributeCanOnlyBeUsedOnMembers);
}
auto diffThisType = getDifferentialType(m_astBuilder, thisType, derivativeMemberAttr->loc);
if (!thisType)
{
getSink()->diagnose(
derivativeMemberAttr,
Diagnostics::invalidUseOfDerivativeMemberAttributeParentTypeIsNotDifferentiable);
}
SLANG_ASSERT(derivativeMemberAttr->args.getCount() == 1);
auto checkedExpr = dispatchExpr(derivativeMemberAttr->args[0], allowStaticReferenceToNonStaticMember());
if (auto declRefExpr = as<DeclRefExpr>(checkedExpr))
{
derivativeMemberAttr->memberDeclRef = declRefExpr;
if (!diffType->equals(declRefExpr->type))
{
getSink()->diagnose(derivativeMemberAttr, Diagnostics::typeMismatch, diffType, declRefExpr->type);
}
if (!varDecl->parentDecl)
{
getSink()->diagnose(derivativeMemberAttr, Diagnostics::attributeNotApplicable, diffType, declRefExpr->type);
}
if (auto memberExpr = as<StaticMemberExpr>(declRefExpr))
{
auto baseExprType = memberExpr->baseExpression->type.type;
if (auto typeType = as<TypeType>(baseExprType))
{
if (diffThisType->equals(typeType->getType()))
{
return;
}
}
}
}
getSink()->diagnose(
derivativeMemberAttr,
Diagnostics::
derivativeMemberAttributeMustNameAMemberInExpectedDifferentialType,
diffThisType);
}
void SemanticsDeclHeaderVisitor::checkExtensionExternVarAttribute(VarDeclBase* varDecl, ExtensionExternVarModifier* extensionExternMemberModifier)
{
if (const auto parentExtension = as<ExtensionDecl>(varDecl->parentDecl))
{
if (auto originalVarDecl = extensionExternMemberModifier->originalDecl.as<VarDeclBase>())
{
auto originalType = GetTypeForDeclRef(originalVarDecl, originalVarDecl.getLoc());
auto extVarType = varDecl->type;
if (!extVarType.type || !extVarType.type->equals(originalType))
{
getSink()->diagnose(varDecl, Diagnostics::typeOfExternDeclMismatchesOriginalDefinition, varDecl, originalType);
}
else
{
return;
}
}
else
{
getSink()->diagnose(varDecl, Diagnostics::definitionOfExternDeclMismatchesOriginalDefinition, varDecl);
}
}
}
void SemanticsDeclHeaderVisitor::checkVarDeclCommon(VarDeclBase* varDecl)
{
// A variable that didn't have an explicit type written must
// have its type inferred from the initial-value expression.
//
if(!varDecl->type.exp)
{
// In this case we need to perform all checking of the
// variable (including semantic checking of the initial-value
// expression) during the first phase of checking.
auto initExpr = varDecl->initExpr;
if(!initExpr)
{
if (!varDecl->type.type)
{
getSink()->diagnose(varDecl, Diagnostics::varWithoutTypeMustHaveInitializer);
varDecl->type.type = m_astBuilder->getErrorType();
}
}
else
{
initExpr = CheckExpr(initExpr);
// TODO: We might need some additional steps here to ensure
// that the type of the expression is one we are okay with
// inferring. E.g., if we ever decide that integer and floating-point
// literals have a distinct type from the standard int/float types,
// then we would need to "decay" a literal to an explicit type here.
varDecl->initExpr = initExpr;
varDecl->type.type = initExpr->type;
_validateCircularVarDefinition(varDecl);
}
// If we've gone down this path, then the variable
// declaration is actually pretty far along in checking
varDecl->setCheckState(DeclCheckState::DefinitionChecked);
}
else
{
// A variable with an explicit type is simpler, for the
// most part.
TypeExp typeExp = CheckUsableType(varDecl->type);
varDecl->type = typeExp;
if (varDecl->type.equals(m_astBuilder->getVoidType()))
{
getSink()->diagnose(varDecl, Diagnostics::invalidTypeVoid);
}
// If this is an unsized array variable, then we first want to give
// it a chance to infer an array size from its initializer
//
// TODO(tfoley): May need to extend this to handle the
// multi-dimensional case...
//
if(isUnsizedArrayType(varDecl->type))
{
if (auto initExpr = varDecl->initExpr)
{
initExpr = CheckTerm(initExpr);
initExpr = coerce(CoercionSite::Initializer, varDecl->type.Ptr(), initExpr);
varDecl->initExpr = initExpr;
maybeInferArraySizeForVariable(varDecl);
varDecl->setCheckState(DeclCheckState::DefinitionChecked);
}
}
//
// Next we want to make sure that the declared (or inferred)
// size for the array meets whatever language-specific
// constraints we want to enforce (e.g., disallow empty
// arrays in specific cases)
//
validateArraySizeForVariable(varDecl);
}
// If there is a matrix layout modifier, we will modify the matrix type now.
if (auto matrixType = as<MatrixExpressionType>(varDecl->type.type))
{
if (auto matrixLayoutModifier = varDecl->findModifier<MatrixLayoutModifier>())
{
auto matrixLayout = as<ColumnMajorLayoutModifier>(matrixLayoutModifier) ? SLANG_MATRIX_LAYOUT_COLUMN_MAJOR : SLANG_MATRIX_LAYOUT_ROW_MAJOR;
auto newMatrixType = getASTBuilder()->getMatrixType(
matrixType->getElementType(),
matrixType->getRowCount(),
matrixType->getColumnCount(),
getASTBuilder()->getIntVal(getASTBuilder()->getIntType(), matrixLayout));
varDecl->type.type = newMatrixType;
if (varDecl->initExpr)
varDecl->initExpr = coerce(CoercionSite::Initializer, varDecl->type, varDecl->initExpr);
}
}
checkMeshOutputDecl(varDecl);
// The NVAPI library allows user code to express extended operations
// (not supported natively by D3D HLSL) by communicating with
// a specially identified shader parameter called `g_NvidiaExt`.
//
// By default, that shader parameter would look like an ordinary
// global shader parameter to Slang, but we want to be able to
// associate special behavior with it to make downstream compilation
// work nicely (especially in the case where certain cross-platform
// operations in the Slang standard library need to use NVAPI).
//
// We will detect a global variable declaration that appears to
// be declaring `g_NvidiaExt` from NVAPI, and mark it with a special
// modifier to allow downstream steps to detect it whether or
// not it has an associated name.
//
if( as<ModuleDecl>(varDecl->parentDecl)
&& varDecl->getName()
&& varDecl->getName()->text == "g_NvidiaExt" )
{
addModifier(varDecl, m_astBuilder->create<NVAPIMagicModifier>());
}
//
// One thing that the `NVAPIMagicModifier` is going to do is ensure
// that `g_NvidiaExt` always gets emitted with *exactly* that name,
// whether or not obfuscation or other steps are enabled.
//
// The `g_NvidiaExt` variable is declared as a:
//
// RWStructuredBuffer<NvShaderExtnStruct>
//
// and we also want to make sure that the fields of that struct
// retain their original names in output code. We will detect
// variable declarations that represent fields of that struct
// and flag them as "magic" as well.
//
// Note: The goal here is to make it so that generated HLSL output
// can either use these declarations as they have been preocessed
// by the Slang front-end *or* they can use declarations directly
// from the NVAPI header during downstream compilation.
//
// TODO: It would be nice if we had a way to identify *all* of the
// declarations that come from the NVAPI header and mark them, so
// that the Slang front-end doesn't have to take responsibility
// for generating code from them (and can instead rely on the downstream
// compiler alone).
//
// The NVAPI header doesn't put any kind of macro-defined modifier
// (defaulting to an empty macro) in front of its declarations,
// so the most plausible way to add a modifier to all the declarations
// would be to tag the `nvHLSLExtns.h` header in a list of "magic"
// headers which should get all their declarations flagged during
// front-end processing, and then use the same header again during
// downstream compilation.
//
// For now, the current hackery seems a bit less complicated.
//
if( auto structDecl = as<StructDecl>(varDecl->parentDecl))
{
if( structDecl->getName()
&& structDecl->getName()->text == "NvShaderExtnStruct" )
{
addModifier(varDecl, m_astBuilder->create<NVAPIMagicModifier>());
}
}
if (const auto interfaceDecl = as<InterfaceDecl>(varDecl->parentDecl))
{
if (auto basicType = as<BasicExpressionType>(varDecl->getType()))
{
switch (basicType->getBaseType())
{
case BaseType::Bool:
case BaseType::Int8:
case BaseType::Int16:
case BaseType::Int:
case BaseType::Int64:
case BaseType::IntPtr:
case BaseType::UInt8:
case BaseType::UInt16:
case BaseType::UInt:
case BaseType::UInt64:
case BaseType::UIntPtr:
break;
default:
getSink()->diagnose(varDecl, Diagnostics::staticConstRequirementMustBeIntOrBool);
break;
}
}
if (!varDecl->findModifier<HLSLStaticModifier>() || !varDecl->findModifier<ConstModifier>())
{
getSink()->diagnose(varDecl, Diagnostics::valueRequirementMustBeCompileTimeConst);
}
}
// Check modifiers that can't be checked earlier during modifier checking stage.
if (auto derivativeMemberAttr = varDecl->findModifier<DerivativeMemberAttribute>())
{
checkDerivativeMemberAttribute(varDecl, derivativeMemberAttr);
}
if (auto extensionExternAttr = varDecl->findModifier<ExtensionExternVarModifier>())
{
checkExtensionExternVarAttribute(varDecl, extensionExternAttr);
}
// If a var decl has no_diff type, move the no_diff modifier from the type to the var.
if (auto modifiedType = as<ModifiedType>(varDecl->type.type))
{
if (auto nodiffModifier = modifiedType->findModifier<NoDiffModifierVal>())
{
varDecl->type.type = getRemovedModifierType(modifiedType, nodiffModifier);
auto noDiffModifier = m_astBuilder->create<NoDiffModifier>();
noDiffModifier->loc = varDecl->loc;
addModifier(varDecl, noDiffModifier);
}
}
if (as<NamespaceDeclBase>(varDecl->parentDecl))
{
// If this is a global variable with [vk::push_constant] attribute,
// we need to make sure to wrap it in a `ConstantBuffer`.
if (!as<ConstantBufferType>(varDecl->type))
{
if (varDecl->findModifier<PushConstantAttribute>())
{
varDecl->type.type = m_astBuilder->getConstantBufferType(varDecl->type);
}
}
if (getModuleDecl(varDecl)->hasModifier<GLSLModuleModifier>())
{
// If we are in GLSL compatiblity mode, we want to treat all global variables
// without any `uniform` modifiers as true global variables by default.
if (!varDecl->findModifier<HLSLUniformModifier>() &&
!varDecl->findModifier<InModifier>() &&
!varDecl->findModifier<OutModifier>() &&
!varDecl->findModifier<GLSLBufferModifier>())
{
if (!as<ResourceType>(varDecl->type) && !as<PointerLikeType>(varDecl->type))
{
auto staticModifier = m_astBuilder->create<HLSLStaticModifier>();
addModifier(varDecl, staticModifier);
}
}
}
}
// Propagate type tags.
if (auto parentAggTypeDecl = as<AggTypeDecl>(getParentDecl(varDecl)))
{
if (auto varDeclRefType = as<DeclRefType>(varDecl->type.type))
{
parentAggTypeDecl->unionTagsWith(getTypeTags(varDeclRefType));
}
}
checkVisibility(varDecl);
}
void SemanticsDeclHeaderVisitor::visitStructDecl(StructDecl* structDecl)
{
// As described above in `SemanticsDeclHeaderVisitor::checkVarDeclCommon`,
// we want to identify and tag the "magic" declarations that make NVAPI
// work, so that downstream passes can identify them and act accordingly.
//
// In this case, we are looking for the `NvShaderExtnStruct` type, which
// is used by `g_NvidiaExt`.
//
if( structDecl->getName()
&& structDecl->getName()->text == "NvShaderExtnStruct" )
{
addModifier(structDecl, m_astBuilder->create<NVAPIMagicModifier>());
}
if (structDecl->hasModifier<ExternModifier>())
{
structDecl->addTag(TypeTag::Incomplete);
}
// Slang supports a convenient syntax to create a wrapper type from
// an existing type that implements a given interface. For example,
// the user can write: struct FooWrapper:IFoo = Foo;
// In this case we will synthesize the FooWrapper type with an inner
// member of type `Foo`, and use it to implement all requirements of
// IFoo.
// If this is a wrapper struct, synthesize the inner member now.
if (structDecl->wrappedType.exp)
{
structDecl->wrappedType = CheckProperType(structDecl->wrappedType);
auto member = m_astBuilder->create<VarDecl>();
member->type = structDecl->wrappedType;
member->nameAndLoc.name = getName("inner");
member->nameAndLoc.loc = structDecl->wrappedType.exp->loc;
member->loc = member->nameAndLoc.loc;
structDecl->addMember(member);
}
checkVisibility(structDecl);
}
void SemanticsDeclHeaderVisitor::visitClassDecl(ClassDecl* classDecl)
{
if (classDecl->hasModifier<ExternModifier>())
{
classDecl->addTag(TypeTag::Incomplete);
}
checkVisibility(classDecl);
}
void SemanticsDeclBodyVisitor::checkVarDeclCommon(VarDeclBase* varDecl)
{
if (auto initExpr = varDecl->initExpr)
{
// If the variable has an explicit initial-value expression,
// then we simply need to check that expression and coerce
// it to the type of the variable.
//
initExpr = CheckTerm(initExpr);
initExpr = coerce(CoercionSite::Initializer, varDecl->type.Ptr(), initExpr);
varDecl->initExpr = initExpr;
// We need to ensure that any variable doesn't introduce
// a constant with a circular definition.
//
varDecl->setCheckState(DeclCheckState::DefinitionChecked);
_validateCircularVarDefinition(varDecl);
}
else
{
// If a variable doesn't have an explicit initial-value
// expression, it is still possible that it should
// be initialized implicitly, because the type of the
// variable has a default (zero parameter) initializer.
// That is, for types where it is possible, we will
// treat a variable declared like this:
//
// MyType myVar;
//
// as if it were declared as:
//
// MyType myVar = MyType();
//
// Rather than try to code up an ad hoc search for an
// appropriate initializer here, we will instead fall
// back on the general-purpose overload-resolution
// machinery, which can handle looking up initializers
// and filtering them to ones that are applicable
// to our "call site" with zero arguments.
//
auto type = varDecl->getType();
OverloadResolveContext overloadContext;
overloadContext.loc = varDecl->nameAndLoc.loc;
overloadContext.mode = OverloadResolveContext::Mode::JustTrying;
overloadContext.sourceScope = m_outerScope;
AddTypeOverloadCandidates(type, overloadContext);
if(overloadContext.bestCandidates.getCount() != 0)
{
// If there were multiple equally-good candidates to call,
// then might have an ambiguity.
//
// Before issuing any kind of diagnostic we need to check
// if any of those candidates are actually applicable,
// because if they aren't then we actually just have
// an uninitialized varaible.
//
if(overloadContext.bestCandidates[0].status != OverloadCandidate::Status::Applicable)
return;
getSink()->diagnose(varDecl, Diagnostics::ambiguousDefaultInitializerForType, type);
}
else if(overloadContext.bestCandidate)
{
// If we are in the single-candidate case, then we again
// want to ignore the case where that candidate wasn't
// actually applicable, because declaring a variable
// of a type that *doesn't* have a default initializer
// isn't actually an error.
//
if(overloadContext.bestCandidate->status != OverloadCandidate::Status::Applicable)
return;
// If we had a single best candidate *and* it was applicable,
// then we use it to construct a new initial-value expression
// for the variable, that will be used for all downstream
// code generation.
//
varDecl->initExpr = CompleteOverloadCandidate(overloadContext, *overloadContext.bestCandidate);
}
}
if (auto elementType = getConstantBufferElementType(varDecl->getType()))
{
if (doesTypeHaveTag(elementType, TypeTag::Incomplete))
{
getSink()->diagnose(varDecl->type.exp->loc, Diagnostics::incompleteTypeCannotBeUsedInBuffer, elementType);
}
}
else if (varDecl->findModifier<HLSLUniformModifier>())
{
auto varType = varDecl->getType();
if (doesTypeHaveTag(varType, TypeTag::Incomplete))
{
getSink()->diagnose(varDecl->type.exp->loc, Diagnostics::incompleteTypeCannotBeUsedInUniformParameter, varType);
}
}
maybeRegisterDifferentiableType(getASTBuilder(), varDecl->getType());
}
// Fill in default substitutions for the 'subtype' part of a type constraint decl
void SemanticsVisitor::CheckConstraintSubType(TypeExp& typeExp)
{
if (auto sharedTypeExpr = as<SharedTypeExpr>(typeExp.exp))
{
if (auto declRefType = as<DeclRefType>(sharedTypeExpr->base))
{
auto newDeclRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, declRefType->getDeclRef());
auto newType = DeclRefType::create(m_astBuilder, newDeclRef);
sharedTypeExpr->base.type = newType;
if (as<TypeType>(typeExp.exp->type))
typeExp.exp->type = m_astBuilder->getTypeType(newType);
}
}
}
void addVisibilityModifier(ASTBuilder* builder, Decl* decl, DeclVisibility vis)
{
switch (vis)
{
case DeclVisibility::Public:
addModifier(decl, builder->create<PublicModifier>());
break;
case DeclVisibility::Internal:
addModifier(decl, builder->create<InternalModifier>());
break;
case DeclVisibility::Private:
addModifier(decl, builder->create<PrivateModifier>());
break;
default:
break;
}
}
bool SemanticsVisitor::trySynthesizeDifferentialAssociatedTypeRequirementWitness(
ConformanceCheckingContext* context,
DeclRef<AssocTypeDecl> requirementDeclRef,
RefPtr<WitnessTable> witnessTable)
{
ASTSynthesizer synth(m_astBuilder, getNamePool());
Decl* existingDecl = nullptr;
AggTypeDecl* aggTypeDecl = nullptr;
if (context->parentDecl->getMemberDictionary().tryGetValue(requirementDeclRef.getName(), existingDecl))
{
// Remove the `ToBeSynthesizedModifier`.
if (as<ToBeSynthesizedModifier>(existingDecl->modifiers.first))
{
existingDecl->modifiers.first = existingDecl->modifiers.first->next;
}
else
{
// The user has defined an associatedtype explicitly but that we reach here because
// that type failed to satisfy the `IDifferential` requirement.
// We stop the synthesis and let the follow-up logic to report a diagnostic.
return false;
}
aggTypeDecl = as<AggTypeDecl>(existingDecl);
SLANG_RELEASE_ASSERT(aggTypeDecl);
synth.pushContainerScope(aggTypeDecl);
}
else
{
aggTypeDecl = m_astBuilder->create<StructDecl>();
aggTypeDecl->parentDecl = context->parentDecl;
context->parentDecl->members.add((aggTypeDecl));
aggTypeDecl->nameAndLoc.name = requirementDeclRef.getName();
aggTypeDecl->loc = context->parentDecl->nameAndLoc.loc;
context->parentDecl->invalidateMemberDictionary();
synth.pushScopeForContainer(aggTypeDecl);
}
// If `This` is nested inside a generic, we need to form a complete declref type to the
// newly synthesized aggTypeDecl here. This can be done by obtaining the this type witness
// from requirementDeclRef to get the generic arguments for the outer generic, and
// apply it to the newly synthesized decl.
SubstitutionSet substSet;
if (auto thisWitness = findThisTypeWitness(
SubstitutionSet(requirementDeclRef),
as<InterfaceDecl>(requirementDeclRef.getParent()).getDecl()))
{
if (auto declRefType = as<DeclRefType>(thisWitness->getSub()))
{
substSet = SubstitutionSet(declRefType->getDeclRef());
}
}
auto satisfyingType = DeclRefType::create(m_astBuilder, m_astBuilder->getMemberDeclRef(substSet.declRef, aggTypeDecl));
// Helper function to add a `diffType` field into the synthesized type for the original
// `member`.
auto differentialType = DeclRefType::create(m_astBuilder, DeclRef<Decl>(makeDeclRef(aggTypeDecl)));
auto addDiffMember = [&](Decl* member, Type* diffMemberType)
{
// If the field is differentiable, add a corresponding field in the associated Differential type.
auto diffField = m_astBuilder->create<VarDecl>();
diffField->nameAndLoc = member->nameAndLoc;
diffField->type.type = diffMemberType;
diffField->checkState = DeclCheckState::SignatureChecked;
diffField->parentDecl = aggTypeDecl;
aggTypeDecl->members.add(diffField);
auto visibility = getDeclVisibility(member);
addVisibilityModifier(m_astBuilder, diffField, visibility);
aggTypeDecl->invalidateMemberDictionary();
// Inject a `DerivativeMember` modifier on the differential field to point to itself.
{
auto derivativeMemberModifier = m_astBuilder->create<DerivativeMemberAttribute>();
auto fieldLookupExpr = m_astBuilder->create<StaticMemberExpr>();
fieldLookupExpr->type.type = diffMemberType;
auto baseTypeExpr = m_astBuilder->create<SharedTypeExpr>();
baseTypeExpr->base.type = differentialType;
auto baseTypeType = m_astBuilder->getOrCreate<TypeType>(differentialType);
baseTypeExpr->type.type = baseTypeType;
fieldLookupExpr->baseExpression = baseTypeExpr;
fieldLookupExpr->declRef = makeDeclRef(diffField);
derivativeMemberModifier->memberDeclRef = fieldLookupExpr;
addModifier(diffField, derivativeMemberModifier);
}
// Inject a `DerivativeMember` modifier on the original decl.
{
auto derivativeMemberModifier = m_astBuilder->create<DerivativeMemberAttribute>();
auto fieldLookupExpr = m_astBuilder->create<StaticMemberExpr>();
fieldLookupExpr->type.type = diffMemberType;
auto baseTypeExpr = m_astBuilder->create<SharedTypeExpr>();
baseTypeExpr->base.type = differentialType;
auto baseTypeType = m_astBuilder->getOrCreate<TypeType>(differentialType);
baseTypeExpr->type.type = baseTypeType;
fieldLookupExpr->baseExpression = baseTypeExpr;
fieldLookupExpr->declRef = makeDeclRef(diffField);
derivativeMemberModifier->memberDeclRef = fieldLookupExpr;
addModifier(member, derivativeMemberModifier);
}
};
// Make the Differential type itself conform to `IDifferential` interface.
bool hasDifferentialConformance = false;
for (auto inheritanceDecl : aggTypeDecl->getMembersOfType<InheritanceDecl>())
{
if (auto declRefType = as<DeclRefType>(inheritanceDecl->base.type))
{
if (declRefType->getDeclRef() == m_astBuilder->getDifferentiableInterfaceDecl())
{
hasDifferentialConformance = true;
break;
}
}
}
if (!hasDifferentialConformance)
{
auto inheritanceIDiffernetiable = m_astBuilder->create<InheritanceDecl>();
inheritanceIDiffernetiable->base.type = m_astBuilder->getDiffInterfaceType();
inheritanceIDiffernetiable->parentDecl = aggTypeDecl;
aggTypeDecl->members.add(inheritanceIDiffernetiable);
}
// The `Differential` type of a `Differential` type is always itself.
bool hasDifferentialTypeDef = false;
for (auto member : aggTypeDecl->members)
{
if (auto name = member->getName())
{
if (name->text == "Differential")
{
hasDifferentialTypeDef = true;
break;
}
}
}
if (!hasDifferentialTypeDef)
{
auto assocTypeDef = m_astBuilder->create<TypeDefDecl>();
assocTypeDef->nameAndLoc.name = getName("Differential");
assocTypeDef->type.type = satisfyingType;
assocTypeDef->parentDecl = aggTypeDecl;
assocTypeDef->setCheckState(DeclCheckState::DefinitionChecked);
aggTypeDecl->members.add(assocTypeDef);
}
// Go through all members and collect their differential types.
// Go through super types.
for (auto inheritance : context->parentDecl->getMembersOfType<InheritanceDecl>())
{
if (auto baseDeclRefType = as<DeclRefType>(inheritance->base.type))
{
// Skip interface super types.
if (baseDeclRefType->getDeclRef().as<InterfaceDecl>())
continue;
if (auto superDiffType = tryGetDifferentialType(m_astBuilder, baseDeclRefType))
{
addDiffMember(inheritance, superDiffType);
}
}
}
// Go through all var members.
for (auto member : context->parentDecl->getMembersOfType<VarDeclBase>())
{
if (member->hasModifier<NoDiffModifier>())
continue;
auto diffType = tryGetDifferentialType(m_astBuilder, member->type.type);
if (!diffType)
continue;
addDiffMember(member, diffType);
}
addModifier(aggTypeDecl, m_astBuilder->create<SynthesizedModifier>());
// The visibility of synthesized decl should be the min of the parent decl and the requirement.
if (requirementDeclRef.getDecl()->findModifier<VisibilityModifier>())
{
auto requirementVisibility = getDeclVisibility(requirementDeclRef.getDecl());
auto thisVisibility = getDeclVisibility(context->parentDecl);
auto visibility = Math::Min(thisVisibility, requirementVisibility);
addVisibilityModifier(m_astBuilder, aggTypeDecl, visibility);
}
// Synthesize the rest of IDifferential method conformances by recursively checking
// conformance on the synthesized decl.
checkAggTypeConformance(aggTypeDecl);
if (doesTypeSatisfyAssociatedTypeConstraintRequirement(satisfyingType, requirementDeclRef, witnessTable))
{
witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(satisfyingType));
// Incrase the epoch so that future calls to Type::getCanonicalType will return the up-to-date folded types.
m_astBuilder->incrementEpoch();
return true;
}
// Note: the call to `doesTypeSatisfyAssociatedTypeConstraintRequirement` should always succeed.
// If not, there is something wrong with the code synthesis logic. For now we just return false
// instead of crashing so the user can work around the issues.
return false;
}
void SemanticsDeclHeaderVisitor::visitGenericTypeConstraintDecl(GenericTypeConstraintDecl* decl)
{
// TODO: are there any other validations we can do at this point?
//
// There probably needs to be a kind of "occurs check" to make
// sure that the constraint actually applies to at least one
// of the parameters of the generic.
//
CheckConstraintSubType(decl->sub);
decl->sub = TranslateTypeNodeForced(decl->sub);
decl->sup = TranslateTypeNodeForced(decl->sup);
}
void SemanticsDeclHeaderVisitor::visitGenericTypeParamDecl(GenericTypeParamDecl* decl)
{
// TODO: could probably push checking the default value
// for a generic type parameter later.
//
decl->initType = CheckProperType(decl->initType);
}
void SemanticsDeclHeaderVisitor::visitGenericValueParamDecl(GenericValueParamDecl* decl)
{
checkVarDeclCommon(decl);
}
void SemanticsDeclHeaderVisitor::visitGenericDecl(GenericDecl* genericDecl)
{
genericDecl->setCheckState(DeclCheckState::ReadyForLookup);
// NOTE! We purposefully do not iterate with the for(auto m : genericDecl->members) here,
// because the visitor may add to `members` whilst iteration takes place, invalidating the iterator
// and likely a crash.
//
// Accessing the members via index side steps the issue.
const auto& members = genericDecl->members;
for (Index i = 0; i < members.getCount(); ++i)
{
Decl* m = members[i];
if (auto typeParam = as<GenericTypeParamDecl>(m))
{
ensureDecl(typeParam, DeclCheckState::ReadyForReference);
}
else if (auto valParam = as<GenericValueParamDecl>(m))
{
ensureDecl(valParam, DeclCheckState::ReadyForReference);
}
else if (auto constraint = as<GenericTypeConstraintDecl>(m))
{
ensureDecl(constraint, DeclCheckState::ReadyForReference);
}
}
}
void SemanticsDeclBasesVisitor::visitInheritanceDecl(InheritanceDecl* inheritanceDecl)
{
// check the type being inherited from
auto base = inheritanceDecl->base;
CheckConstraintSubType(base);
base = TranslateTypeNode(base);
inheritanceDecl->base = base;
// Note: we do not check whether the type being inherited from
// is valid to use for inheritance here, because there could
// be contextual factors that need to be taken into account
// based on the declaration that is doing the inheriting.
}
void SemanticsDeclBasesVisitor::visitThisTypeConstraintDecl(ThisTypeConstraintDecl* thisTypeConstraintDecl)
{
// Make sure IFoo<T>.This.ThisIsIFooConstraint.base.type is properly set
// to DeclRefType(IFoo<T>) with default generic arguments.
if (!thisTypeConstraintDecl->base.type)
{
auto parentTypeDecl = getParentDecl(getParentDecl(thisTypeConstraintDecl));
thisTypeConstraintDecl->base.type = DeclRefType::create(
m_astBuilder,
createDefaultSubstitutionsIfNeeded(
m_astBuilder,
this,
getDefaultDeclRef(parentTypeDecl)));
}
}
// Concretize interface conformances so that we have witnesses as required for lookup.
// for lookup.
struct SemanticsDeclConformancesVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclConformancesVisitor>
{
SemanticsDeclConformancesVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
// Any user-defined type may have declared interface conformances,
// which we should check.
//
void visitAggTypeDecl(AggTypeDecl* aggTypeDecl)
{
checkAggTypeConformance(aggTypeDecl);
}
// Conformances can also come via `extension` declarations, and
// we should check them against the type(s) being extended.
//
void visitExtensionDecl(ExtensionDecl* extensionDecl)
{
checkExtensionConformance(extensionDecl);
}
};
// Check that types used as `Differential` type use themselves as their own `Differential` type.
struct SemanticsDeclDifferentialConformanceVisitor
: public SemanticsDeclVisitorBase
, public DeclVisitor<SemanticsDeclDifferentialConformanceVisitor>
{
SemanticsDeclDifferentialConformanceVisitor(SemanticsContext const& outer)
: SemanticsDeclVisitorBase(outer)
{}
void visitDecl(Decl*) {}
void visitDeclGroup(DeclGroup*) {}
void visitInheritanceDecl(InheritanceDecl* inheritanceDecl)
{
if (as<InterfaceDecl>(inheritanceDecl->parentDecl))
return;
if (!inheritanceDecl->witnessTable)
return;
auto baseType = as<DeclRefType>(inheritanceDecl->witnessTable->baseType);
if (!baseType)
return;
if (baseType->getDeclRef().getDecl() != m_astBuilder->getDifferentiableInterfaceDecl().getDecl())
return;
RequirementWitness witnessValue;
auto requirementDecl = m_astBuilder->getSharedASTBuilder()->findBuiltinRequirementDecl(BuiltinRequirementKind::DifferentialType);
if (!inheritanceDecl->witnessTable->getRequirementDictionary().tryGetValue(requirementDecl, witnessValue))
return;
// A type used as differential type must have itself as its own differential type.
if (witnessValue.getFlavor() != RequirementWitness::Flavor::val)
return;
auto differentialType = as<DeclRefType>(witnessValue.getVal());
if (!differentialType)
return;
auto diffDiffType = tryGetDifferentialType(m_astBuilder, differentialType);
if (!differentialType->equals(diffDiffType))
{
SourceLoc sourceLoc = differentialType->getDeclRef().getDecl()->loc;
getSink()->diagnose(inheritanceDecl, Diagnostics::differentialTypeShouldServeAsItsOwnDifferentialType, differentialType, diffDiffType);
getSink()->diagnose(sourceLoc, Diagnostics::seeDefinitionOf, differentialType);
}
}
};
/// Recursively register any builtin declarations that need to be attached to the `session`.
///
/// This function should only be needed for declarations in the standard library.
///
static void _registerBuiltinDeclsRec(Session* session, Decl* decl)
{
SharedASTBuilder* sharedASTBuilder = session->m_sharedASTBuilder;
if (auto builtinMod = decl->findModifier<BuiltinTypeModifier>())
{
sharedASTBuilder->registerBuiltinDecl(decl, builtinMod);
}
if (auto magicMod = decl->findModifier<MagicTypeModifier>())
{
sharedASTBuilder->registerMagicDecl(decl, magicMod);
}
if (auto builtinRequirement = decl->findModifier<BuiltinRequirementModifier>())
{
sharedASTBuilder->registerBuiltinRequirementDecl(decl, builtinRequirement);
}
if(auto containerDecl = as<ContainerDecl>(decl))
{
for(auto childDecl : containerDecl->members)
{
if(as<ScopeDecl>(childDecl))
continue;
_registerBuiltinDeclsRec(session, childDecl);
}
}
if(auto genericDecl = as<GenericDecl>(decl))
{
_registerBuiltinDeclsRec(session, genericDecl->inner);
}
}
void registerBuiltinDecls(Session* session, Decl* decl)
{
_registerBuiltinDeclsRec(session, decl);
}
void SemanticsDeclVisitorBase::checkModule(ModuleDecl* moduleDecl)
{
// When we are dealing with code from the standard library,
// there is a potential problem where we might need to look
// up built-in types like `Int` through the session (e.g.,
// to determine the type for an integer literal), but those
// types might not have been registered yet. We solve that
// by doing a pre-process on standard-library code to find
// and register any built-in declarations.
//
// TODO: This could be factored into another visitor pass
// that fits the more standard checking below, but that would
// seemingly add overhead to checking things other than
// the standard library.
//
if(isFromStdLib(moduleDecl))
{
_registerBuiltinDeclsRec(getSession(), moduleDecl);
}
if (moduleDecl->members.getCount() > 0)
{
auto firstMember = moduleDecl->members[0];
if (as<ImplementingDecl>(firstMember))
{
if (!getShared()->isInLanguageServer())
{
// A primary module file can't start with an "implementing" declaration.
getSink()->diagnose(firstMember, Diagnostics::primaryModuleFileCannotStartWithImplementingDecl);
}
}
else if (!as<ModuleDeclarationDecl>(firstMember))
{
// A primary module file must start with a `module` declaration.
// TODO: this warning is disabled for now to free users from massive change for now.
#if 0
getSink()->diagnose(firstMember, Diagnostics::primaryModuleFileMustStartWithModuleDecl);
#endif
}
}
// We need/want to visit any `import` declarations before
// anything else, to make sure that scoping works.
//
// TODO: This could be factored into another visitor pass
// that fits more with the standard checking below.
//
for(auto importDecl : moduleDecl->getMembersOfType<ImportDecl>())
{
ensureDecl(importDecl, DeclCheckState::DefinitionChecked);
}
// Next, make sure all `__include` decls are processed and the referenced
// files are parsed.
auto visitIncludeDecls = [&](ContainerDecl* fileDecl)
{
for (Index i = 0; i < fileDecl->members.getCount(); i++)
{
auto decl = fileDecl->members[i];
if (auto includeDecl = as<IncludeDecl>(decl))
{
ensureDecl(includeDecl, DeclCheckState::DefinitionChecked);
}
else if (auto implementingDecl = as<ImplementingDecl>(decl))
{
ensureDecl(implementingDecl, DeclCheckState::DefinitionChecked);
}
else if (auto importDecl = as<ImportDecl>(decl))
{
ensureDecl(importDecl, DeclCheckState::DefinitionChecked);
}
}
};
visitIncludeDecls(moduleDecl);
for (Index i = 0; i < moduleDecl->members.getCount(); i++)
{
if (auto fileDecl = as<FileDecl>(moduleDecl->members[i]))
visitIncludeDecls(fileDecl);
}
// The entire goal of semantic checking is to get all of the
// declarations in the module up to `DeclCheckState::DefinitionChecked`.
//
// The main catch is that checking one declaration A up to state M
// may required that declaration B is checked up to state N.
// A call to `ensureDecl(B, N)` can guarantee that things are checked
// when and where we need them, but that runs the risk of creating
// very deep recursion in the semantic checking.
//
// Instead, we would rather do more breadth-first checking,
// where everything gets checked up to state 1, 2, ...
// before anything gets too far ahead.
// We will therefore enumerate the states/phases for checking,
// and then iteratively try to update all declarations to each
// state in turn.
//
// Note: for a simpler language we could eliminate `ensureDecl`
// completely and *just* have these phases of checking.
// Unfortunately, we have some circularity between the phases:
//
// * Checking an overloaded call requires knowing the parameter
// types of all candidate callees.
//
// * Checking the parameter type of a function requires being
// able to check type expressions.
//
// * A type expression like `vector<T, N>` may have an arbitary
// expression for `N`.
//
// * An arbitrary expression may include function calls, which
// may be to overloaded functions.
//
// Languages like C++ solve the apparent problem by making
// restrictions on order of declaration/definition (and by
// requiring forward declarations or the `template`/`typename`
// keywrods in some cases).
//
// TODO: We could eventually eliminate the potential recursion
// in checking by splitting each phase into a "requirements gathering"
// step and an actual execution step.
//
// When checking a declaration D up to state S, the requirements
// gathering step would produce a list of pairs `(someDecl, someState)`
// indicating that `someDecl` must be in `someState` before the
// actual execution of checking for `(D,S)` can proceeed. The checker
// can then produce an elaborated dependency graph and select nodes
// for execution in an order that satisfies all the dependencies.
//
// Such a more elaborate checking scheme will have to wait for another
// day, but might be worth it (or even necessary) if/when we want to
// support incremental compilation.
//
DeclCheckState states[] =
{
DeclCheckState::ScopesWired,
DeclCheckState::ReadyForReference,
DeclCheckState::ReadyForLookup,
DeclCheckState::ReadyForConformances,
DeclCheckState::DefinitionChecked,
DeclCheckState::CapabilityChecked,
};
for(auto s : states)
{
// When advancing to state `s` we will recursively
// advance all declarations rooted in the module
// up to `s`.
//
// TODO: In cases where a large module is split across files,
// we could potentially parallelize front-end compilation by
// having multiple instances of the front end where each is
// only responsible for those declarations in a given file.
//
// Under that model, we might only apply later phases of
// checking (notably the final push to `DeclState::Checked`)
// to the subset of declarations coming from a given source
// file.
//
_ensureAllDeclsRec(this, moduleDecl, s);
}
// Once we have completed the above loop, all declarations not
// nested in function bodies should be in `DeclState::Checked`.
// Furthermore, because a fully checked function will have checked
// its body, this also means that all function bodies and the
// declarations they contain should be fully checked.
}
bool SemanticsVisitor::doesSignatureMatchRequirement(
DeclRef<CallableDecl> satisfyingMemberDeclRef,
DeclRef<CallableDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
if(satisfyingMemberDeclRef.getDecl()->hasModifier<MutatingAttribute>()
!= requiredMemberDeclRef.getDecl()->hasModifier<MutatingAttribute>())
{
// A `[mutating]` method can't satisfy a non-`[mutating]` requirement.
// The opposite direction is okay, but we will need to synthesize a wrapper
// to ensure type matches, so we will return false here either way.
return false;
}
if (satisfyingMemberDeclRef.getDecl()->hasModifier<ConstRefAttribute>()
!= requiredMemberDeclRef.getDecl()->hasModifier<ConstRefAttribute>())
{
// A `[constref]` method can't satisfy a non-`[constref]` requirement.
// The opposite direction is okay, but we will need to synthesize a wrapper
// to ensure type matches, so we will return false here either way.
return false;
}
if(satisfyingMemberDeclRef.getDecl()->hasModifier<HLSLStaticModifier>()
!= requiredMemberDeclRef.getDecl()->hasModifier<HLSLStaticModifier>())
{
// A `static` method can't satisfy a non-`static` requirement and vice versa.
return false;
}
bool hasBackwardDerivative = false;
bool hasForwardDerivative = false;
if (requiredMemberDeclRef.getDecl()->hasModifier<BackwardDifferentiableAttribute>())
{
auto funcDecl = as<FunctionDeclBase>(satisfyingMemberDeclRef.getDecl());
if (!funcDecl)
return false;
if (getShared()->getFuncDifferentiableLevel(funcDecl) != FunctionDifferentiableLevel::Backward)
{
// A non-`BackwardDifferentiable` method can't satisfy a `BackwardDifferentiable` requirement and vice versa.
return false;
}
hasBackwardDerivative = true;
hasForwardDerivative = true;
}
else if (requiredMemberDeclRef.getDecl()->hasModifier<ForwardDifferentiableAttribute>())
{
auto funcDecl = as<FunctionDeclBase>(satisfyingMemberDeclRef.getDecl());
if (!funcDecl)
return false;
if (getShared()->getFuncDifferentiableLevel(funcDecl) == FunctionDifferentiableLevel::None)
{
// A non-`BackwardDifferentiable` method can't satisfy a `BackwardDifferentiable` requirement and vice versa.
return false;
}
hasForwardDerivative = true;
}
// A signature matches the required one if it has the right number of parameters,
// and those parameters have the right types, and also the result/return type
// is the required one.
//
auto requiredParams = getParameters(m_astBuilder, requiredMemberDeclRef).toArray();
auto satisfyingParams = getParameters(m_astBuilder, satisfyingMemberDeclRef).toArray();
auto paramCount = requiredParams.getCount();
if(satisfyingParams.getCount() != paramCount)
return false;
for(Index paramIndex = 0; paramIndex < paramCount; ++paramIndex)
{
auto requiredParam = requiredParams[paramIndex];
auto satisfyingParam = satisfyingParams[paramIndex];
auto requiredParamType = getType(m_astBuilder, requiredParam);
auto satisfyingParamType = getType(m_astBuilder, satisfyingParam);
if(!requiredParamType->equals(satisfyingParamType))
return false;
}
auto requiredResultType = getResultType(m_astBuilder, requiredMemberDeclRef);
auto satisfyingResultType = getResultType(m_astBuilder, satisfyingMemberDeclRef);
if(!requiredResultType->equals(satisfyingResultType))
return false;
if (hasForwardDerivative || hasBackwardDerivative)
{
auto parentInterfaceDecl = as<InterfaceDecl>(getParentDecl(requiredMemberDeclRef.getDecl()));
if (parentInterfaceDecl)
{
bool noDiffThisSatisfying = !isTypeDifferentiable(witnessTable->witnessedType);
bool noDiffThisRequirement = (requiredMemberDeclRef.getDecl()->findModifier<NoDiffThisAttribute>() != nullptr);
if (noDiffThisRequirement != noDiffThisSatisfying)
return false;
}
}
_addMethodWitness(witnessTable, requiredMemberDeclRef, satisfyingMemberDeclRef);
return true;
}
bool SemanticsVisitor::doesAccessorMatchRequirement(
DeclRef<AccessorDecl> satisfyingMemberDeclRef,
DeclRef<AccessorDecl> requiredMemberDeclRef)
{
// We require the AST node class of the satisfying accessor
// to be a subclass of the one from the required accessor.
//
// For our current accessor types, this amounts to requiring
// an exact match, but using a subtype test means that if
// we ever add an `ExtraSpecialGetDecl` that is a subclass
// of `GetDecl`, then one of those would be able to satisfy
// a `get` requirement.
//
auto satisfyingMemberClass = satisfyingMemberDeclRef.getDecl()->getClass();
auto requiredMemberClass = requiredMemberDeclRef.getDecl()->getClass();
if(!satisfyingMemberClass.isSubClassOfImpl(requiredMemberClass))
return false;
// We do not check the parameters or return types of accessors
// here, under the assumption that the validity checks for
// the parent `property` declaration would already make sure
// they are in order.
// TODO: There are other checks we need to make here, like not letting
// an ordinary `set` satisfy a `[nonmutating] set` requirement.
return true;
}
bool SemanticsVisitor::doesPropertyMatchRequirement(
DeclRef<PropertyDecl> satisfyingMemberDeclRef,
DeclRef<PropertyDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// The type of the satisfying member must match the type of the required member.
//
// Note: It is possible that a `get`-only property could be satisfied by
// a declaration that uses a subtype of the requirement, but that would not
// count as an "exact match" and we would rely on the logic to synthesize
// a stub implementation in that case.
//
auto satisfyingType = getType(getASTBuilder(), satisfyingMemberDeclRef);
auto requiredType = getType(getASTBuilder(), requiredMemberDeclRef);
if(!satisfyingType->equals(requiredType))
return false;
// Each accessor in the requirement must be accounted for by an accessor
// in the satisfying member.
//
// Note: it is fine for the satisfying member to provide *more* accessors
// than the original declaration.
//
Dictionary<DeclRef<AccessorDecl>, DeclRef<AccessorDecl>> mapRequiredToSatisfyingAccessorDeclRef;
for( auto requiredAccessorDeclRef : getMembersOfType<AccessorDecl>(m_astBuilder, requiredMemberDeclRef) )
{
// We need to search for an accessor that can satisfy the requirement.
//
// For now we will do the simplest (and slowest) thing of a linear search,
// which is mostly fine because the number of accessors is bounded.
//
bool found = false;
for( auto satisfyingAccessorDeclRef : getMembersOfType<AccessorDecl>(m_astBuilder, satisfyingMemberDeclRef) )
{
if( doesAccessorMatchRequirement(satisfyingAccessorDeclRef, requiredAccessorDeclRef) )
{
// When we find a match on an accessor, we record it so that
// we can set up the witness values later, but we do *not*
// record it into the actual witness table yet, in case
// a later accessor comes along that doesn't find a match.
//
mapRequiredToSatisfyingAccessorDeclRef.add(requiredAccessorDeclRef, satisfyingAccessorDeclRef);
found = true;
break;
}
}
if(!found)
return false;
}
// Once things are done, we will install the satisfying values
// into the witness table for the requirements.
//
for( const auto& [key, value] : mapRequiredToSatisfyingAccessorDeclRef )
{
witnessTable->add(
key.getDecl(),
RequirementWitness(value));
}
//
// Note: the property declaration itself isn't something that
// has a useful value/representation in downstream passes, so
// we are mostly just installing it into the witness table
// as a way to mark this requirement as being satisfied.
//
// TODO: It is possible that having a witness table entry that
// doesn't actually map to any IR value could create a problem
// in downstream passes. If such propblems arise, we should
// probably create a new `RequirementWitness` case that
// represents a witness value that is only needed by the front-end,
// and that can be ignored by IR and emit logic.
//
witnessTable->add(
requiredMemberDeclRef.getDecl(),
RequirementWitness(satisfyingMemberDeclRef));
return true;
}
bool SemanticsVisitor::doesSubscriptMatchRequirement(
DeclRef<SubscriptDecl> satisfyingMemberDeclRef,
DeclRef<SubscriptDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// The result type and parameters of the satisfying member must match the type of the required member.
//
auto requiredParams = getParameters(m_astBuilder, requiredMemberDeclRef).toArray();
auto satisfyingParams = getParameters(m_astBuilder, satisfyingMemberDeclRef).toArray();
auto paramCount = requiredParams.getCount();
if (satisfyingParams.getCount() != paramCount)
return false;
for (Index paramIndex = 0; paramIndex < paramCount; ++paramIndex)
{
auto requiredParam = requiredParams[paramIndex];
auto satisfyingParam = satisfyingParams[paramIndex];
auto requiredParamType = getType(m_astBuilder, requiredParam);
auto satisfyingParamType = getType(m_astBuilder, satisfyingParam);
if (!requiredParamType->equals(satisfyingParamType))
return false;
}
auto requiredResultType = getResultType(m_astBuilder, requiredMemberDeclRef);
auto satisfyingResultType = getResultType(m_astBuilder, satisfyingMemberDeclRef);
if (!requiredResultType->equals(satisfyingResultType))
return false;
// Each accessor in the requirement must be accounted for by an accessor
// in the satisfying member.
//
// Note: it is fine for the satisfying member to provide *more* accessors
// than the original declaration.
//
Dictionary<DeclRef<AccessorDecl>, DeclRef<AccessorDecl>> mapRequiredToSatisfyingAccessorDeclRef;
for (auto requiredAccessorDeclRef : getMembersOfType<AccessorDecl>(m_astBuilder, requiredMemberDeclRef))
{
// We need to search for an accessor that can satisfy the requirement.
//
// For now we will do the simplest (and slowest) thing of a linear search,
// which is mostly fine because the number of accessors is bounded.
//
bool found = false;
for (auto satisfyingAccessorDeclRef : getMembersOfType<AccessorDecl>(m_astBuilder, satisfyingMemberDeclRef))
{
if (doesAccessorMatchRequirement(satisfyingAccessorDeclRef, requiredAccessorDeclRef))
{
// When we find a match on an accessor, we record it so that
// we can set up the witness values later, but we do *not*
// record it into the actual witness table yet, in case
// a later accessor comes along that doesn't find a match.
//
mapRequiredToSatisfyingAccessorDeclRef.add(requiredAccessorDeclRef, satisfyingAccessorDeclRef);
found = true;
break;
}
}
if (!found)
return false;
}
// Once things are done, we will install the satisfying values
// into the witness table for the requirements.
//
for (const auto& [key, value] : mapRequiredToSatisfyingAccessorDeclRef)
{
witnessTable->add(
key.getDecl(),
RequirementWitness(value));
}
//
// Note: the subscript declaration itself isn't something that
// has a useful value/representation in downstream passes, so
// we are mostly just installing it into the witness table
// as a way to mark this requirement as being satisfied.
//
witnessTable->add(
requiredMemberDeclRef.getDecl(),
RequirementWitness(satisfyingMemberDeclRef));
return true;
}
bool SemanticsVisitor::doesVarMatchRequirement(
DeclRef<VarDeclBase> satisfyingMemberDeclRef,
DeclRef<VarDeclBase> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// The type of the satisfying member must match the type of the required member.
auto satisfyingType = getType(getASTBuilder(), satisfyingMemberDeclRef);
auto requiredType = getType(getASTBuilder(), requiredMemberDeclRef);
if (!satisfyingType->equals(requiredType))
return false;
for (auto modifier : requiredMemberDeclRef.getDecl()->modifiers)
{
bool found = false;
for (auto satisfyingModifier : satisfyingMemberDeclRef.getDecl()->modifiers)
{
if (satisfyingModifier->astNodeType == modifier->astNodeType)
{
found = true;
break;
}
}
if (!found)
return false;
}
auto satisfyingVal = tryConstantFoldDeclRef(satisfyingMemberDeclRef, nullptr);
if (satisfyingVal)
{
witnessTable->add(
requiredMemberDeclRef.getDecl(),
RequirementWitness(satisfyingVal));
}
else
{
witnessTable->add(
requiredMemberDeclRef.getDecl(),
RequirementWitness(satisfyingMemberDeclRef));
}
return true;
}
bool SemanticsVisitor::doesGenericSignatureMatchRequirement(
DeclRef<GenericDecl> satisfyingGenericDeclRef,
DeclRef<GenericDecl> requiredGenericDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// The signature of a generic is defiend by its members, and we need the
// satisfying value to have the same number of members for it to be an
// exact match.
//
auto memberCount = requiredGenericDeclRef.getDecl()->members.getCount();
if(satisfyingGenericDeclRef.getDecl()->members.getCount() != memberCount)
return false;
// We then want to check that pairwise members match, in order.
//
auto requiredMemberDeclRefs = getMembers(m_astBuilder, requiredGenericDeclRef);
auto satisfyingMemberDeclRefs = getMembers(m_astBuilder, satisfyingGenericDeclRef);
//
// We start by performing a superficial "structural" match of the parameters
// to ensure that the two generics have an equivalent mix of type, value,
// and constraint parameters in the same order.
//
// Note that in this step we do *not* make any checks on the actual types
// involved in constraints, or on the types of value parameters. The reason
// for this is that the types on those parameters could be dependent on
// type parameters in the generic parameter list, and thus there could be
// a mismatch at this point. For example, if we have:
//
// interface IBase { void doThing<T, U : IThing<T>>(); }
// struct Derived : IBase { void doThing<X, Y : IThing<X>>(); }
//
// We clearly have a signature match here, but the constraint parameters for
// `U : IThing<T>` and `Y : IThing<X>` have the problem that both the sub-type
// and super-type they reference are not equivalent without substititions.
//
// We will deal with this issue after the structural matching is checked, at
// which point we can actually verify things like types.
//
for (Index i = 0; i < memberCount; i++)
{
auto requiredMemberDeclRef = requiredMemberDeclRefs[i];
auto satisfyingMemberDeclRef = satisfyingMemberDeclRefs[i];
if (as<GenericTypeParamDecl>(requiredMemberDeclRef))
{
if (as<GenericTypeParamDecl>(satisfyingMemberDeclRef))
{
}
else
return false;
}
else if (auto requiredValueParamDeclRef = requiredMemberDeclRef.as<GenericValueParamDecl>())
{
if (auto satisfyingValueParamDeclRef = satisfyingMemberDeclRef.as<GenericValueParamDecl>())
{
}
else
return false;
}
else if (auto requiredConstraintDeclRef = requiredMemberDeclRef.as<GenericTypeConstraintDecl>())
{
if (auto satisfyingConstraintDeclRef = satisfyingMemberDeclRef.as<GenericTypeConstraintDecl>())
{
}
else
return false;
}
}
// In order to compare the inner declarations of the two generics, we need to
// align them so that they are expressed in terms of consistent type parameters.
//
// For example, we might have:
//
// interface IBase { void doThing<T>(T val); }
// struct Derived : IBase { void doThing<U>(U val); }
//
// If we directly compare the signatures of the inner `doThing` function declarations,
// we'd find a mismatch between the `T` and `U` types of the `val` parameter.
//
// We can get around this mismatch by constructing a specialized reference and
// then doing the comparison. For example `IBase::doThing<X>` and `Derived::doThing<X>`
// should both have the signature `X -> void`.
//
// The one big detail that we need to be careful about here is that when we
// recursively call `doesMemberSatisfyRequirement`, that will eventually store
// the satisfying `DeclRef` as the value for the given requirement key, and we don't
// want to store a specialized reference like `Derived::doThing<X>` - we need to
// somehow store the original declaration.
//
// The solution here is to specialize the *required* declaration to the parameters
// of the satisfying declaration. In the example above that means we are going to
// compare `Derived::doThing` against `IBase::doThing<U>` where the `U` there is
// the parameter of `Dervived::doThing`.
//
List<Val*> requiredSubstArgs;
for (Index i = 0; i < memberCount; i++)
{
auto requiredMemberDeclRef = requiredMemberDeclRefs[i];
auto satisfyingMemberDeclRef = satisfyingMemberDeclRefs[i];
if(auto requiredTypeParamDeclRef = requiredMemberDeclRef.as<GenericTypeParamDecl>())
{
auto satisfyingTypeParamDeclRef = satisfyingMemberDeclRef.as<GenericTypeParamDecl>();
SLANG_ASSERT(satisfyingTypeParamDeclRef);
auto satisfyingType = DeclRefType::create(m_astBuilder, satisfyingTypeParamDeclRef);
requiredSubstArgs.add(satisfyingType);
}
else if (auto requiredValueParamDeclRef = requiredMemberDeclRef.as<GenericValueParamDecl>())
{
auto satisfyingValueParamDeclRef = satisfyingMemberDeclRef.as<GenericValueParamDecl>();
SLANG_ASSERT(satisfyingValueParamDeclRef);
auto satisfyingVal = m_astBuilder->getOrCreate<GenericParamIntVal>(
requiredValueParamDeclRef.getDecl()->getType(),
satisfyingValueParamDeclRef);
satisfyingVal->getDeclRef() = satisfyingValueParamDeclRef;
requiredSubstArgs.add(satisfyingVal);
}
}
for (Index i = 0; i < memberCount; i++)
{
auto requiredMemberDeclRef = requiredMemberDeclRefs[i];
auto satisfyingMemberDeclRef = satisfyingMemberDeclRefs[i];
if(auto requiredConstraintDeclRef = requiredMemberDeclRef.as<GenericTypeConstraintDecl>())
{
auto satisfyingConstraintDeclRef = satisfyingMemberDeclRef.as<GenericTypeConstraintDecl>();
SLANG_ASSERT(satisfyingConstraintDeclRef);
auto satisfyingWitness = m_astBuilder->getDeclaredSubtypeWitness(
getSub(m_astBuilder, satisfyingConstraintDeclRef),
getSup(m_astBuilder, satisfyingConstraintDeclRef),
satisfyingConstraintDeclRef);
requiredSubstArgs.add(satisfyingWitness);
}
}
// Now that we have computed a set of specialization arguments that will
// specialize the generic requirement at the type parameters of the satisfying
// generic, we can construct a reference to that declaration and re-run some
// of the earlier checking logic with more type information usable.
//
auto specializedRequiredGenericInnerDeclRef = m_astBuilder->getGenericAppDeclRef(
requiredGenericDeclRef, requiredSubstArgs.getArrayView());
for (Index i = 0; i < memberCount; i++)
{
auto requiredMemberDeclRef = requiredMemberDeclRefs[i];
auto satisfyingMemberDeclRef = satisfyingMemberDeclRefs[i];
if(auto requiredTypeParamDeclRef = requiredMemberDeclRef.as<GenericTypeParamDecl>())
{
[[maybe_unused]] auto satisfyingTypeParamDeclRef = satisfyingMemberDeclRef.as<GenericTypeParamDecl>();
SLANG_ASSERT(satisfyingTypeParamDeclRef);
// There are no additional checks we need to make on plain old
// type parameters at this point.
//
// TODO: If we ever support having type parameters of higher kinds,
// then this is possibly where we'd want to check that the kinds of
// the two parameters match.
//
}
else if (auto requiredValueParamDeclRef = requiredMemberDeclRef.as<GenericValueParamDecl>())
{
auto satisfyingValueParamDeclRef = satisfyingMemberDeclRef.as<GenericValueParamDecl>();
SLANG_ASSERT(satisfyingValueParamDeclRef);
// For a generic value parameter, we need to check that the required
// and satisfying declaration both agree on the type of the parameter.
//
auto requiredParamType = getType(m_astBuilder, requiredValueParamDeclRef);
auto satisfyingParamType = getType(m_astBuilder, satisfyingValueParamDeclRef);
if (!satisfyingParamType->equals(requiredParamType))
return false;
}
else if(auto requiredConstraintDeclRef = requiredMemberDeclRef.as<GenericTypeConstraintDecl>())
{
auto satisfyingConstraintDeclRef = satisfyingMemberDeclRef.as<GenericTypeConstraintDecl>();
SLANG_ASSERT(satisfyingConstraintDeclRef);
// For a generic constraint parameter, we need to check that the sub-type
// and super-type in the constraint both match.
//
// In current code the sub type will always be one of the generic type parameters,
// and the super-type will always be an interface, but there should be no
// need to make use of those additional details here.
auto specializedRequiredConstraintDeclRef = m_astBuilder->getGenericAppDeclRef(
requiredGenericDeclRef,
requiredSubstArgs.getArrayView(),
requiredConstraintDeclRef.getDecl()).as<GenericTypeConstraintDecl>();
auto requiredSubType = getSub(m_astBuilder, specializedRequiredConstraintDeclRef);
auto satisfyingSubType = getSub(m_astBuilder, satisfyingConstraintDeclRef);
if (!satisfyingSubType->equals(requiredSubType))
return false;
auto requiredSuperType = getSup(m_astBuilder, specializedRequiredConstraintDeclRef);
auto satisfyingSuperType = getSup(m_astBuilder, satisfyingConstraintDeclRef);
if (!satisfyingSuperType->equals(requiredSuperType))
return false;
}
}
// Note: the above logic really only applies to the case of an exact match on signature,
// even down to the way that constraints were declared. We could potentially be more
// relaxed by taking advantage of the way that various different generic signatures will
// actually lower to the same IR generic signature.
//
// In theory, all we really care about when it comes to constraints is that the constraints
// on the required and satisfying declaration are *equivalent*.
//
// More generally, a satisfying generic could actually provide *looser* constraints and
// still work; all that matters is that it can be instantiated at any argument values/types
// that are valid for the requirement.
//
// We leave both of those issues up to the synthesis path: if we do not find a member that
// provides an exact match, then the compiler should try to synthesize one that is an exact
// match and makes use of existing declarations that might have require defaulting of arguments
// or type conversations to fit.
// Once we've validated that the generic signatures are in an exact match, and devised type
// arguments for the requirement to make the two align, we can recursively check the inner
// declaration (whatever it is) for an exact match.
//
return doesMemberSatisfyRequirement(
m_astBuilder->getMemberDeclRef(satisfyingGenericDeclRef, getInner(satisfyingGenericDeclRef)),
specializedRequiredGenericInnerDeclRef,
witnessTable);
}
bool SemanticsVisitor::doesTypeSatisfyAssociatedTypeConstraintRequirement(Type* satisfyingType, DeclRef<AssocTypeDecl> requiredAssociatedTypeDeclRef, RefPtr<WitnessTable> witnessTable)
{
// We will enumerate the type constraints placed on the
// associated type and see if they can be satisfied.
//
bool conformance = true;
Val* witness = nullptr;
for (auto requiredConstraintDeclRef : getMembersOfType<TypeConstraintDecl>(m_astBuilder, requiredAssociatedTypeDeclRef))
{
// Grab the type we expect to conform to from the constraint.
auto requiredSuperType = getSup(m_astBuilder, requiredConstraintDeclRef);
// Perform a search for a witness to the subtype relationship.
witness = tryGetSubtypeWitness(satisfyingType, requiredSuperType);
if (witness)
{
// If a subtype witness was found, then the conformance
// appears to hold, and we can satisfy that requirement.
witnessTable->add(requiredConstraintDeclRef.getDecl(), RequirementWitness(witness));
}
else
{
// If a witness couldn't be found, then the conformance
// seems like it will fail.
conformance = false;
}
}
return conformance;
}
bool SemanticsVisitor::doesTypeSatisfyAssociatedTypeRequirement(
Type* satisfyingType,
DeclRef<AssocTypeDecl> requiredAssociatedTypeDeclRef,
RefPtr<WitnessTable> witnessTable)
{
if (auto declRefType = as<DeclRefType>(satisfyingType))
{
// If we are seeing a placeholder that awaits synthesis, return false now to trigger
// auto synthesis.
if (declRefType->getDeclRef().getDecl()->hasModifier<ToBeSynthesizedModifier>())
return false;
}
// We need to confirm that the chosen type `satisfyingType`,
// meets all the constraints placed on the associated type
// requirement `requiredAssociatedTypeDeclRef`.
//
// We will enumerate the type constraints placed on the
// associated type and see if they can be satisfied.
//
bool conformance = doesTypeSatisfyAssociatedTypeConstraintRequirement(
satisfyingType, requiredAssociatedTypeDeclRef, witnessTable);
// TODO: if any conformance check failed, we should probably include
// that in an error message produced about not satisfying the requirement.
if(conformance)
{
// If all the constraints were satisfied, then the chosen
// type can indeed satisfy the interface requirement.
witnessTable->add(
requiredAssociatedTypeDeclRef.getDecl(),
RequirementWitness(satisfyingType->getCanonicalType()));
}
return conformance;
}
bool SemanticsVisitor::doesMemberSatisfyRequirement(
DeclRef<Decl> memberDeclRef,
DeclRef<Decl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// Sanity check: if are checking whether a type `T`
// implements, say, `IFoo::bar` and lookup of `bar`
// in type `T` yielded `IFoo::bar`, then that shouldn't
// be treated as a valid satisfaction of the requirement.
//
// TODO: Ideally this check should be comparing the `DeclRef`s
// and not just the `Decl`s, but we currently don't get exactly
// the same substitutions when we see the inherited `IFoo::bar`.
//
if(memberDeclRef.getDecl() == requiredMemberDeclRef.getDecl())
return false;
// At a high level, we want to check that the
// `memberDecl` and the `requiredMemberDeclRef`
// have the same AST node class, and then also
// check that their signatures match.
//
// There are a bunch of detailed decisions that
// have to be made, though, because we might, e.g.,
// allow a function with more general parameter
// types to satisfy a requirement with more
// specific parameter types.
//
// If we ever allow for "property" declarations,
// then we would probably need to allow an
// ordinary field to satisfy a property requirement.
//
// An associated type requirement should be allowed
// to be satisfied by any type declaration:
// a typedef, a `struct`, etc.
//
if (auto memberFuncDecl = memberDeclRef.as<FuncDecl>())
{
if (auto requiredFuncDeclRef = requiredMemberDeclRef.as<FuncDecl>())
{
// Check signature match.
return doesSignatureMatchRequirement(
memberFuncDecl,
requiredFuncDeclRef,
witnessTable);
}
}
else if (auto memberInitDecl = memberDeclRef.as<ConstructorDecl>())
{
if (auto requiredInitDecl = requiredMemberDeclRef.as<ConstructorDecl>())
{
// Check signature match.
return doesSignatureMatchRequirement(
memberInitDecl,
requiredInitDecl,
witnessTable);
}
}
else if (auto genDecl = memberDeclRef.as<GenericDecl>())
{
// For a generic member, we will check if it can satisfy
// a generic requirement in the interface.
//
// TODO: we could also conceivably check that the generic
// could be *specialized* to satisfy the requirement,
// and then install a specialization of the generic into
// the witness table. Actually doing this would seem
// to require performing something akin to overload
// resolution as part of requirement satisfaction.
//
if (auto requiredGenDeclRef = requiredMemberDeclRef.as<GenericDecl>())
{
return doesGenericSignatureMatchRequirement(genDecl, requiredGenDeclRef, witnessTable);
}
}
else if (auto subAggTypeDeclRef = memberDeclRef.as<AggTypeDecl>())
{
if(auto requiredTypeDeclRef = requiredMemberDeclRef.as<AssocTypeDecl>())
{
ensureDecl(subAggTypeDeclRef, DeclCheckState::CanUseAsType);
auto satisfyingType = DeclRefType::create(m_astBuilder, subAggTypeDeclRef);
return doesTypeSatisfyAssociatedTypeRequirement(satisfyingType, requiredTypeDeclRef, witnessTable);
}
}
else if (auto typedefDeclRef = memberDeclRef.as<TypeDefDecl>())
{
// this is a type-def decl in an aggregate type
// check if the specified type satisfies the constraints defined by the associated type
if (auto requiredTypeDeclRef = requiredMemberDeclRef.as<AssocTypeDecl>())
{
ensureDecl(typedefDeclRef, DeclCheckState::ReadyForLookup);
auto satisfyingType = getNamedType(m_astBuilder, typedefDeclRef);
return doesTypeSatisfyAssociatedTypeRequirement(satisfyingType, requiredTypeDeclRef, witnessTable);
}
}
else if( auto propertyDeclRef = memberDeclRef.as<PropertyDecl>() )
{
if( auto requiredPropertyDeclRef = requiredMemberDeclRef.as<PropertyDecl>() )
{
ensureDecl(propertyDeclRef, DeclCheckState::CanUseFuncSignature);
return doesPropertyMatchRequirement(propertyDeclRef, requiredPropertyDeclRef, witnessTable);
}
}
else if (auto varDeclRef = memberDeclRef.as<VarDeclBase>())
{
if (auto requiredVarDeclRef = requiredMemberDeclRef.as<VarDeclBase>())
{
ensureDecl(varDeclRef, DeclCheckState::SignatureChecked);
return doesVarMatchRequirement(varDeclRef, requiredVarDeclRef, witnessTable);
}
}
else if (auto subscriptDeclRef = memberDeclRef.as<SubscriptDecl>())
{
if (auto requiredSubscriptDeclRef = requiredMemberDeclRef.as<SubscriptDecl>())
{
ensureDecl(subscriptDeclRef, DeclCheckState::CanUseFuncSignature);
return doesSubscriptMatchRequirement(subscriptDeclRef, requiredSubscriptDeclRef, witnessTable);
}
}
// Default: just assume that thing aren't being satisfied.
return false;
}
GenericDecl* SemanticsVisitor::synthesizeGenericSignatureForRequirementWitness(
ConformanceCheckingContext* context,
DeclRef<GenericDecl> requiredMemberDeclRef,
List<Expr*>& synArgs,
List<Expr*>& synGenericArgs,
ThisExpr*& synThis)
{
auto synGenericDecl = m_astBuilder->create<GenericDecl>();
// For now our synthesized method will use the name and source
// location of the requirement we are trying to satisfy.
//
// TODO: as it stands right now our syntesized method will
// get a mangled name, which we don't actually want. Leaving
// out the name here doesn't help matters, because then *all*
// snthesized methods on a given type would share the same
// mangled name!
//
synGenericDecl->nameAndLoc = requiredMemberDeclRef.getDecl()->nameAndLoc;
if (synGenericDecl->nameAndLoc.name)
{
synGenericDecl->nameAndLoc.name = getSession()->getNameObj("$__syn_" + synGenericDecl->nameAndLoc.name->text);
}
// Dictionary to map from the original type parameters to the synthesized ones.
Dictionary<GenericTypeParamDecl*, GenericTypeParamDecl*> mapOrigToSynTypeParams;
// Our synthesized method will have parameters matching the names
// and types of those on the requirement, and it will use expressions
// that reference those parametesr as arguments for the call expresison
// that makes up the body.
//
for (auto member : requiredMemberDeclRef.getDecl()->members)
{
if (auto typeParamDecl = as<GenericTypeParamDecl>(member))
{
auto synTypeParamDecl = m_astBuilder->create<GenericTypeParamDecl>();
synTypeParamDecl->nameAndLoc = typeParamDecl->getNameAndLoc();
synTypeParamDecl->initType = typeParamDecl->initType;
synTypeParamDecl->parentDecl = synGenericDecl;
synGenericDecl->members.add(synTypeParamDecl);
mapOrigToSynTypeParams.add(typeParamDecl, synTypeParamDecl);
// Construct a DeclRefExpr from the type parameter.
auto synTypeParamDeclRef = makeDeclRef(synTypeParamDecl);
auto synTypeParamDeclRefExpr = m_astBuilder->create<VarExpr>();
synTypeParamDeclRefExpr->declRef = synTypeParamDeclRef;
synTypeParamDeclRefExpr->type = getTypeForDeclRef(m_astBuilder, synTypeParamDeclRef, SourceLoc());
synGenericArgs.add(synTypeParamDeclRefExpr);
}
}
for (auto member : requiredMemberDeclRef.getDecl()->members)
{
if (auto constraintDecl = as<GenericTypeConstraintDecl>(member))
{
auto synConstraintDecl = m_astBuilder->create<GenericTypeConstraintDecl>();
synConstraintDecl->nameAndLoc = constraintDecl->getNameAndLoc();
synConstraintDecl->parentDecl = synGenericDecl;
// For constraints of type T : Interface, where T is a simple type parameter,
// find the declaration of T
//
if (auto typeParamDecl = as<DeclRefType>(constraintDecl->sub.type)->getDeclRef().as<GenericTypeParamDecl>().getDecl())
{
auto synTypeParamDecl = mapOrigToSynTypeParams.getValue(typeParamDecl);
// Construct a DeclRefExpr from the type parameter.
auto synTypeParamDeclRef = makeDeclRef(synTypeParamDecl);
auto synTypeParamDeclRefExpr = m_astBuilder->create<VarExpr>();
synTypeParamDeclRefExpr->declRef = synTypeParamDeclRef;
synTypeParamDeclRefExpr->type = getTypeForDeclRef(m_astBuilder, synTypeParamDeclRef, SourceLoc());
synConstraintDecl->sub = TypeExp(synTypeParamDeclRefExpr);
synConstraintDecl->sup = constraintDecl->sup;
synGenericDecl->members.add(synConstraintDecl);
}
else
{
SLANG_UNEXPECTED("Cannot perform synthesis for requirements with complex type constraints.");
}
}
}
// Override generic pointer to point to the original generic container.
// This will create a substitution of the synthesized parameters for the
// original parameters.
//
auto defaultArgs = getDefaultSubstitutionArgs(m_astBuilder, this, synGenericDecl);
DeclRef<FuncDecl> requiredFuncDeclRef = m_astBuilder->getGenericAppDeclRef(
requiredMemberDeclRef, defaultArgs.getArrayView()).as<FuncDecl>();
SLANG_ASSERT(requiredFuncDeclRef);
synGenericDecl->inner = synthesizeMethodSignatureForRequirementWitness(
context,
requiredFuncDeclRef,
synArgs,
synThis);
synGenericDecl->inner->parentDecl = synGenericDecl;
return synGenericDecl;
}
FuncDecl* SemanticsVisitor::synthesizeMethodSignatureForRequirementWitness(
ConformanceCheckingContext* context,
DeclRef<FuncDecl> requiredMemberDeclRef,
List<Expr*>& synArgs,
ThisExpr*& synThis)
{
auto synFuncDecl = m_astBuilder->create<FuncDecl>();
synFuncDecl->ownedScope = m_astBuilder->create<Scope>();
synFuncDecl->ownedScope->containerDecl = synFuncDecl;
synFuncDecl->ownedScope->parent = getScope(context->parentDecl);
// For now our synthesized method will use the name and source
// location of the requirement we are trying to satisfy.
//
// TODO: as it stands right now our syntesized method will
// get a mangled name, which we don't actually want. Leaving
// out the name here doesn't help matters, because then *all*
// snthesized methods on a given type would share the same
// mangled name!
//
synFuncDecl->nameAndLoc = requiredMemberDeclRef.getDecl()->nameAndLoc;
if (synFuncDecl->nameAndLoc.name)
{
synFuncDecl->nameAndLoc.name = getSession()->getNameObj("$__syn_" + synFuncDecl->nameAndLoc.name->text);
}
// The result type of our synthesized method will be the expected
// result type from the interface requirement.
//
// TODO: This logic can/will run into problems if the return type
// is an associated type.
//
// The ideal solution is that we should be solving for interface
// conformance in two phases: a first phase to solve for how
// associated types are satisfied, and then a second phase to solve
// for how other requirements are satisfied (where we can substitute
// in the associated type witnesses for the abstract associated
// types as part of `requiredMemberDeclRef`).
//
// TODO: We should also double-check that this logic will work
// with a method that returns `This`.
//
auto resultType = getResultType(m_astBuilder, requiredMemberDeclRef);
synFuncDecl->returnType.type = resultType;
// Our synthesized method will have parameters matching the names
// and types of those on the requirement, and it will use expressions
// that reference those parametesr as arguments for the call expresison
// that makes up the body.
//
for (auto paramDeclRef : getParameters(m_astBuilder, requiredMemberDeclRef))
{
auto paramType = getType(m_astBuilder, paramDeclRef);
// For each parameter of the requirement, we create a matching
// parameter (same name and type) for the synthesized method.
//
auto synParamDecl = m_astBuilder->create<ParamDecl>();
synParamDecl->nameAndLoc = paramDeclRef.getDecl()->nameAndLoc;
synParamDecl->type.type = paramType;
// We need to add the parameter as a child declaration of
// the method we are building.
//
synParamDecl->parentDecl = synFuncDecl;
synFuncDecl->members.add(synParamDecl);
// For each paramter, we will create an argument expression
// for the call in the function body.
//
auto synArg = m_astBuilder->create<VarExpr>();
synArg->declRef = makeDeclRef(synParamDecl);
synArg->type = paramType;
synArgs.add(synArg);
// Add modifiers
for (auto modifier : paramDeclRef.getDecl()->modifiers)
{
if (as<NoDiffModifier>(modifier))
{
auto noDiffModifier = m_astBuilder->create<NoDiffModifier>();
noDiffModifier->keywordName = getSession()->getNameObj("no_diff");
addModifier(synParamDecl, noDiffModifier);
}
else if (as<InOutModifier>(modifier) || as<OutModifier>(modifier) || as<ConstRefModifier>(modifier) || as<RefModifier>(modifier))
{
auto clonedModifier = (Modifier*)m_astBuilder->createByNodeType(modifier->astNodeType);
clonedModifier->keywordName = modifier->keywordName;
addModifier(synParamDecl, clonedModifier);
}
}
}
// Required interface methods can be `static` or non-`static`,
// and non-`static` methods can be `[mutating]` or non-`[mutating]`.
// All of these details affect how we introduce our `this` parameter,
// if any.
//
if (requiredMemberDeclRef.getDecl()->hasModifier<HLSLStaticModifier>())
{
auto synStaticModifier = m_astBuilder->create<HLSLStaticModifier>();
synFuncDecl->modifiers.first = synStaticModifier;
}
else
{
// For a non-`static` requirement, we need a `this` parameter.
//
synThis = m_astBuilder->create<ThisExpr>();
synThis->scope = synFuncDecl->ownedScope;
// The type of `this` in our method will be the type for
// which we are synthesizing a conformance.
//
synThis->type.type = context->conformingType;
if (requiredMemberDeclRef.getDecl()->hasModifier<MutatingAttribute>())
{
// If the interface requirement is `[mutating]` then our
// synthesized method should be too, and also the `this`
// parameter should be an l-value.
//
synThis->type.isLeftValue = true;
auto synMutatingAttr = m_astBuilder->create<MutatingAttribute>();
addModifier(synFuncDecl, synMutatingAttr);
}
if (requiredMemberDeclRef.getDecl()->hasModifier<ConstRefAttribute>())
{
// If the interface requirement is `[constref]` then our
// synthesized method should be too.
//
auto synConstRefAttr = m_astBuilder->create<ConstRefAttribute>();
addModifier(synFuncDecl, synConstRefAttr);
}
if (requiredMemberDeclRef.getDecl()->hasModifier<NoDiffThisAttribute>())
{
auto noDiffThisAttr = m_astBuilder->create<NoDiffThisAttribute>();
addModifier(synFuncDecl, noDiffThisAttr);
}
if (requiredMemberDeclRef.getDecl()->hasModifier<ForwardDifferentiableAttribute>())
{
auto attr = m_astBuilder->create<ForwardDifferentiableAttribute>();
addModifier(synFuncDecl, attr);
}
if (requiredMemberDeclRef.getDecl()->hasModifier<BackwardDifferentiableAttribute>())
{
auto attr = m_astBuilder->create<BackwardDifferentiableAttribute>();
addModifier(synFuncDecl, attr);
}
// The visibility of synthesized decl should be the min of the parent decl and the requirement.
if (requiredMemberDeclRef.getDecl()->findModifier<VisibilityModifier>())
{
auto requirementVisibility = getDeclVisibility(requiredMemberDeclRef.getDecl());
auto thisVisibility = getDeclVisibility(context->parentDecl);
auto visibility = Math::Min(thisVisibility, requirementVisibility);
addVisibilityModifier(m_astBuilder, synFuncDecl, visibility);
}
}
return synFuncDecl;
}
void SemanticsVisitor::_addMethodWitness(
WitnessTable* witnessTable,
DeclRef<CallableDecl> requiredMemberDeclRef,
DeclRef<CallableDecl> satisfyingMemberDeclRef)
{
for (auto reqRefDecl : requiredMemberDeclRef.getDecl()->getMembersOfType<DerivativeRequirementReferenceDecl>())
{
if (auto fwdReq = as<ForwardDerivativeRequirementDecl>(reqRefDecl->referencedDecl))
{
ForwardDifferentiateVal* val = m_astBuilder->getOrCreate<ForwardDifferentiateVal>(satisfyingMemberDeclRef);
witnessTable->add(fwdReq, RequirementWitness(val));
}
else if (auto bwdReq = as<BackwardDerivativeRequirementDecl>(reqRefDecl->referencedDecl))
{
DifferentiateVal* val = m_astBuilder->getOrCreate<BackwardDifferentiateVal>(satisfyingMemberDeclRef);
witnessTable->add(bwdReq, RequirementWitness(val));
}
}
witnessTable->add(requiredMemberDeclRef.getDecl(), RequirementWitness(satisfyingMemberDeclRef));
}
static bool isWrapperTypeDecl(Decl* decl)
{
if (auto aggTypeDecl = as<AggTypeDecl>(decl))
{
if (aggTypeDecl->wrappedType)
return true;
}
return false;
}
bool SemanticsVisitor::trySynthesizeMethodRequirementWitness(
ConformanceCheckingContext* context,
LookupResult const& lookupResult,
DeclRef<FuncDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// The situation here is that the context of an inheritance
// declaration didn't provide an exact match for a required
// method. E.g.:
//
// interface ICounter { [mutating] int increment(); }
// struct MyCounter : ICounter
// {
// [murtating] int increment(int val = 1) { ... }
// }
//
// It is clear in this case that the `MyCounter` type *can*
// satisfy the signature required by `ICounter`, but it has
// no explicit method declaration that is a perfect match.
//
// The approach in this function will be to construct a
// synthesized method along the lines of:
//
// struct MyCounter ...
// {
// ...
// [murtating] int synthesized()
// {
// return this.increment();
// }
// }
//
// That is, we construct a method with the exact signature
// of the requirement (same parameter and result types),
// and then provide it with a body that simple `return`s
// the result of applying the desired requirement name
// (`increment` in this case) to those parameters.
//
// If the synthesized method type-checks, then we can say
// that the type must satisfy the requirement structurally,
// even if there isn't an exact signature match. More
// importantly, the method we just synthesized can be
// used as a witness to the fact that the requirement is
// satisfied.
// With the big picture spelled out, we can settle into
// the work of constructing our synthesized method.
//
// First, we check that the differentiabliity of the method matches the requirement,
// and we don't attempt to synthesize a method if they don't match.
if (getShared()->getFuncDifferentiableLevel(
as<FunctionDeclBase>(lookupResult.item.declRef.getDecl()))
< getShared()->getFuncDifferentiableLevel(
as<FunctionDeclBase>(requiredMemberDeclRef.getDecl())))
{
return false;
}
ThisExpr* synThis = nullptr;
List<Expr*> synArgs;
auto synFuncDecl = synthesizeMethodSignatureForRequirementWitness(
context, requiredMemberDeclRef, synArgs, synThis);
auto resultType = synFuncDecl->returnType.type;
// The body of our synthesized method is going to try to
// make a call using the name of the method requirement (e.g.,
// the name `increment` in our example at the top of this function).
//
// The caller already passed in a `LookupResult` that represents
// an attempt to look up the given name in the type of `this`,
// and we really just need to wrap that result up as an overloaded
// expression.
//
auto synBase = m_astBuilder->create<OverloadedExpr>();
synBase->name = requiredMemberDeclRef.getDecl()->getName();
if (isWrapperTypeDecl(context->parentDecl))
{
auto aggTypeDecl = as<AggTypeDecl>(context->parentDecl);
synBase->lookupResult2 = lookUpMember(
m_astBuilder,
this,
synBase->name,
aggTypeDecl->wrappedType.type,
aggTypeDecl->ownedScope,
LookupMask::Default,
LookupOptions::IgnoreBaseInterfaces);
addModifier(synFuncDecl, m_astBuilder->create<ForceInlineAttribute>());
}
else
{
synBase->lookupResult2 = lookupResult;
}
// If `synThis` is non-null, then we will use it as the base of
// the overloaded expression, so that we have an overloaded
// member reference, and not just an overloaded reference to some
// static definitions.
//
if (synThis)
{
if (isWrapperTypeDecl(context->parentDecl))
{
// If this is a wrapper type, then use the inner
// object as the actual this parameter for the redirected
// call.
auto innerExpr = m_astBuilder->create<VarExpr>();
innerExpr->scope = synThis->scope;
innerExpr->name = getName("inner");
synBase->base = CheckExpr(innerExpr);
}
else
{
synBase->base = synThis;
}
}
// We now have the reference to the overload group we plan to call,
// and we already built up the argument list, so we can construct
// an `InvokeExpr` that represents the call we want to make.
//
auto synCall = m_astBuilder->create<InvokeExpr>();
synCall->functionExpr = synBase;
synCall->arguments = synArgs;
// In order to know if our call is well-formed, we need to run
// the semantic checking logic for overload resolution. If it
// runs into an error, we don't want that being reported back
// to the user as some kind of overload-resolution failure.
//
// In order to protect the user from whatever errors might
// occur, we will perform the checking in the context of
// a temporary diagnostic sink.
//
DiagnosticSink tempSink(getSourceManager(), nullptr);
ExprLocalScope localScope;
SemanticsVisitor subVisitor(withSink(&tempSink).withExprLocalScope(&localScope));
// With our temporary diagnostic sink soaking up any messages
// from overload resolution, we can now try to resolve
// the call to see what happens.
//
auto checkedCall = subVisitor.ResolveInvoke(synCall);
// Of course, it is possible that the call went through fine,
// but the result isn't of the type we expect/require,
// so we also need to coerce the result of the call to
// the expected type.
//
auto coercedCall = subVisitor.coerce(CoercionSite::Return, resultType, checkedCall);
// If our overload resolution or type coercion failed,
// then we have not been able to synthesize a witness
// for the requirement.
//
// TODO: We might want to detect *why* overload resolution
// or type coercion failed, and report errors accordingly.
//
// More detailed diagnostics could help users understand
// what they did wrong, e.g.:
//
// * "We tried to use `foo(int)` but the interface requires `foo(String)`
//
// * "You have two methods that can apply as `bar()` and we couldn't tell which one you meant
//
// For now we just bail out here and rely on the caller to
// diagnose a generic "failed to satisfying requirement" error.
//
if(tempSink.getErrorCount() != 0)
return false;
// If we were able to type-check the call, then we should
// be able to finish construction of a suitable witness.
//
// We've already created the outer declaration (including its
// parameters), and the inner expression, so the main work
// that is left is defining the body of the new function,
// which comprises a single `return` statement.
//
auto synReturn = m_astBuilder->create<ReturnStmt>();
synReturn->expression = coercedCall;
synFuncDecl->body = synReturn;
// Once we are sure that we want to use the declaration
// we've synthesized, aew can go ahead and wire it up
// to the AST so that subsequent stages can generate
// IR code from it.
//
// Note: we set the parent of the synthesized declaration
// to the parent of the inheritance declaration being
// validated (which is either a type declaration or
// an `extension`), but we do *not* add the syntehsized
// declaration to the list of child declarations at
// this point.
//
// By leaving the synthesized declaration off of the list
// of members, we ensure that it doesn't get found
// by lookup (e.g., in a module that `import`s this type).
// Unfortunately, we may also break invariants in other parts
// of the code if they assume that all declarations have
// to appear in the parent/child hierarchy of the module.
//
// TODO: We may need to properly wire the synthesized
// declaration into the hierarchy, but then attach a modifier
// to it to indicate that it should be ignored by things like lookup.
//
synFuncDecl->parentDecl = context->parentDecl;
// Once our synthesized declaration is complete, we need
// to install it as the witness that satifies the given
// requirement.
//
// Subsequent code generation should not be able to tell the
// difference between our synthetic method and a hand-written
// one with the same behavior.
//
_addMethodWitness(witnessTable, requiredMemberDeclRef, makeDeclRef(synFuncDecl));
return true;
}
bool SemanticsVisitor::trySynthesizePropertyRequirementWitness(
ConformanceCheckingContext* context,
LookupResult const& lookupResult,
DeclRef<PropertyDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
if (isWrapperTypeDecl(context->parentDecl))
return trySynthesizeWrapperTypePropertyRequirementWitness(context, requiredMemberDeclRef, witnessTable);
// The situation here is that the context of an inheritance
// declaration didn't provide an exact match for a required
// property. E.g.:
//
// interface ICell { property value : int { get; set; } }
// struct MyCell : ICell
// {
// int value;
// }
//
// It is clear in this case that the `MyCell` type *can*
// satisfy the signature required by `ICell`, but it has
// no explicit `property` declaration, and instead just
// a field with the right name and type.
//
// The approach in this function will be to construct a
// synthesized `preoperty` along the lines of:
//
// struct MyCounter ...
// {
// ...
// property value_synthesized : int
// {
// get { return this.value; }
// set(newValue) { this.value = newValue; }
// }
// }
//
// That is, we construct a `property` with the correct type
// and with an accessor for each requirement, where the accesors
// all try to read or write `this.value`.
//
// If those synthesized accessors all type-check, then we can
// say that the type must satisfy the requirement structurally,
// even if there isn't an exact signature match. More
// importantly, the `property` we just synthesized can be
// used as a witness to the fact that the requirement is
// satisfied.
//
// The big-picture flow of the logic here is similar to
// `trySynthesizeMethodRequirementWitness()` above, and we
// will not comment this code as exhaustively, under the
// assumption that readers of the code don't benefit from
// having the exact same information stated twice.
// With the introduction out of the way, let's get started
// constructing a synthesized `PropertyDecl`.
//
auto synPropertyDecl = m_astBuilder->create<PropertyDecl>();
// Synthesize the property name with a prefix to avoid name clashing.
synPropertyDecl->nameAndLoc = requiredMemberDeclRef.getDecl()->nameAndLoc;
synPropertyDecl->nameAndLoc.name = getName(String("$syn_property_") + getText(requiredMemberDeclRef.getName()));
// The type of our synthesized property will be the expected type
// of the interface requirement.
//
// TODO: This logic can/will run into problems if the type is,
// or uses, an associated type or `This`.
//
// Ideally we should be looking up the type using a `DeclRef` that
// refers to the interface requirement using a `LookupDeclRef`
// that refers to the satisfying type declaration, and requirement
// checking for non-associated-type requirements should be done *after*
// requirement checking for associated-type requirements.
//
auto propertyType = getType(m_astBuilder, requiredMemberDeclRef);
synPropertyDecl->type.type = propertyType;
// Our synthesized property will have an accessor declaration for
// each accessor of the requirement.
//
// TODO: If we ever start to support synthesis for subscript requirements,
// then we probably want to factor the accessor-related logic into
// a subroutine so that it can be shared between properties and subscripts.
//
Dictionary<DeclRef<AccessorDecl>, AccessorDecl*> mapRequiredAccessorToSynAccessor;
for( auto requiredAccessorDeclRef : getMembersOfType<AccessorDecl>(m_astBuilder, requiredMemberDeclRef) )
{
// The synthesized accessor will be an AST node of the same class as
// the required accessor.
//
auto synAccessorDecl = (AccessorDecl*) m_astBuilder->createByNodeType(requiredAccessorDeclRef.getDecl()->astNodeType);
synAccessorDecl->ownedScope = m_astBuilder->create<Scope>();
synAccessorDecl->ownedScope->containerDecl = synAccessorDecl;
synAccessorDecl->ownedScope->parent = getScope(context->parentDecl);
// Whatever the required accessor returns, that is what our synthesized accessor will return.
//
synAccessorDecl->returnType.type = getResultType(m_astBuilder, requiredAccessorDeclRef);
// Similarly, our synthesized accessor will have parameters matching those of the requirement.
//
// Note: in practice we expect that only `set` accessors will have any parameters,
// and they will only have a single parameter.
//
List<Expr*> synArgs;
for( auto requiredParamDeclRef : getParameters(m_astBuilder, requiredAccessorDeclRef) )
{
auto paramType = getType(m_astBuilder, requiredParamDeclRef);
// The synthesized parameter will ahve the same name and
// type as the parameter of the requirement.
//
auto synParamDecl = m_astBuilder->create<ParamDecl>();
synParamDecl->nameAndLoc = requiredParamDeclRef.getDecl()->nameAndLoc;
synParamDecl->type.type = paramType;
// We need to add the parameter as a child declaration of
// the accessor we are building.
//
synParamDecl->parentDecl = synAccessorDecl;
synAccessorDecl->members.add(synParamDecl);
// For each paramter, we will create an argument expression
// to represent it in the body of the accessor.
//
auto synArg = m_astBuilder->create<VarExpr>();
synArg->declRef = makeDeclRef(synParamDecl);
synArg->type = paramType;
synArgs.add(synArg);
}
// We need to create a `this` expression to be used in the body
// of the synthesized accessor.
//
// TODO: if we ever allow `static` properties or subscripts,
// we will need to handle that case here, by *not* creating
// a `this` expression.
//
ThisExpr* synThis = m_astBuilder->create<ThisExpr>();
synThis->scope = synAccessorDecl->ownedScope;
// The type of `this` in our accessor will be the type for
// which we are synthesizing a conformance.
//
synThis->type.type = context->conformingType;
// A `get` accessor should default to an immutable `this`,
// while other accessors default to mutable `this`.
//
// TODO: If we ever add other kinds of accessors, we will
// need to check that this assumption stays valid.
//
synThis->type.isLeftValue = true;
if(as<GetterDecl>(requiredAccessorDeclRef))
synThis->type.isLeftValue = false;
// If the accessor requirement is `[nonmutating]` then our
// synthesized accessor should be too, and also the `this`
// parameter should *not* be an l-value.
//
if( requiredAccessorDeclRef.getDecl()->hasModifier<NonmutatingAttribute>() )
{
synThis->type.isLeftValue = false;
auto synAttr = m_astBuilder->create<NonmutatingAttribute>();
synAccessorDecl->modifiers.first = synAttr;
}
//
// Note: we don't currently support `[mutating] get` accessors,
// but the desired behavior in that case is clear, so we go
// ahead and future-proof this code a bit:
//
else if( requiredAccessorDeclRef.getDecl()->hasModifier<MutatingAttribute>() )
{
synThis->type.isLeftValue = true;
auto synAttr = m_astBuilder->create<MutatingAttribute>();
synAccessorDecl->modifiers.first = synAttr;
}
// We are going to synthesize an expression and then perform
// semantic checking on it, but if there are semantic errors
// we do *not* want to report them to the user as such, and
// instead want the result to be a failure to synthesize
// a valid witness.
//
// We will buffer up diagnostics into a temporary sink and
// then throw them away when we are done.
//
// TODO: This behavior might be something we want to make
// into a more fundamental capability of `DiagnosticSink` and/or
// `SemanticsVisitor` so that code can push/pop the emission
// of diagnostics more easily.
//
DiagnosticSink tempSink(getSourceManager(), nullptr);
SemanticsVisitor subVisitor(withSink(&tempSink));
// We start by constructing an expression that represents
// `this.name` where `name` is the name of the required
// member. The caller already passed in a `lookupResult`
// that should indicate all the declarations found by
// looking up `name`, so we can start with that.
//
// TODO: Note that there are many cases for member lookup
// that are not handled just by using `createLookupResultExpr`
// because they are currently being special-cased (the most
// notable cases are swizzles, as well as lookup of static
// members in types).
//
// The main result here is that we will not be able to synthesize
// a requirement for a built-in scalar/vector/matrix type to
// a property with a name like `.xy` based on the presence of
// swizles, even though it seems like such a thing should Just Work.
//
// If this is important we could "fix" it by allowing this
// code to dispatch to the special-case logic used when doing
// semantic checking for member expressions.
//
// Note: an alternative would be to change the stdlib declarations
// of vectors/matrices so that all the swizzles are defined as
// `property` declarations. There are some C++ math libraries (like GLM)
// that implement swizzle syntax by a similar approach of statically
// enumerating all possible swizzles. The down-side to such an
// approach is that the combinatorial space of swizzles is quite
// large (especially for matrices) so that supporting them via
// general-purpose language features is unlikely to be as efficient
// as special-case logic.
//
auto synMemberRef = subVisitor.createLookupResultExpr(
requiredMemberDeclRef.getName(),
lookupResult,
synThis,
requiredMemberDeclRef.getLoc(),
nullptr);
synMemberRef->loc = requiredMemberDeclRef.getLoc();
// The body of the accessor will depend on the class of the accessor
// we are synthesizing (e.g., `get` vs. `set`).
//
Stmt* synBodyStmt = nullptr;
if( as<GetterDecl>(requiredAccessorDeclRef) )
{
// A `get` accessor will simply perform:
//
// return this.name;
//
// which involves coercing the member access `this.name` to
// the expected type of the property.
//
auto coercedMemberRef = subVisitor.coerce(CoercionSite::Return, propertyType, synMemberRef);
auto synReturn = m_astBuilder->create<ReturnStmt>();
synReturn->expression = coercedMemberRef;
synBodyStmt = synReturn;
}
else if( as<SetterDecl>(requiredAccessorDeclRef) )
{
// We expect all `set` accessors to have a single argument,
// but we will defensively bail out if that is somehow
// not the case.
//
SLANG_ASSERT(synArgs.getCount() == 1);
if(synArgs.getCount() != 1)
return false;
// A `set` accessor will simply perform:
//
// this.name = newValue;
//
// which involves creating and checking an assignment
// expression.
auto synAssign = m_astBuilder->create<AssignExpr>();
synAssign->left = synMemberRef;
synAssign->right = synArgs[0];
auto synCheckedAssign = subVisitor.checkAssignWithCheckedOperands(synAssign);
auto synExprStmt = m_astBuilder->create<ExpressionStmt>();
synExprStmt->expression = synCheckedAssign;
synBodyStmt = synExprStmt;
}
else
{
// While there are other kinds of accessors than `get` and `set`,
// those are currently only reserved for stdlib-internal use.
// We will not bother with synthesis for those cases.
//
return false;
}
// We bail out if we ran into any errors (meaning that the synthesized
// accessor is not usable).
//
// TODO: If there were *warnings* emitted to the sink, it would probably
// be good to show those warnings to the user, since they might indicate
// real issues. E.g., with the current logic a `float` field could
// satisfying an `int` property requirement, but the user would probably
// want to be warned when they do such a thing.
//
if(tempSink.getErrorCount() != 0)
return false;
synAccessorDecl->body = synBodyStmt;
synAccessorDecl->parentDecl = synPropertyDecl;
synPropertyDecl->members.add(synAccessorDecl);
// If synthesis of an accessor worked, then we will record it into
// a local dictionary. We do *not* install the accessor into the
// witness table yet, because it is possible that synthesis will
// succeed for some accessors but not others, and we don't want
// to leave the witness table in a state where a requirement is
// "partially satisfied."
//
mapRequiredAccessorToSynAccessor.add(requiredAccessorDeclRef, synAccessorDecl);
}
synPropertyDecl->parentDecl = context->parentDecl;
// The visibility of synthesized decl should be the min of the parent decl and the requirement.
if (requiredMemberDeclRef.getDecl()->findModifier<VisibilityModifier>())
{
auto requirementVisibility = getDeclVisibility(requiredMemberDeclRef.getDecl());
auto thisVisibility = getDeclVisibility(context->parentDecl);
auto visibility = Math::Min(thisVisibility, requirementVisibility);
addVisibilityModifier(m_astBuilder, synPropertyDecl, visibility);
}
// Once our synthesized declaration is complete, we need
// to install it as the witness that satifies the given
// requirement.
//
// Subsequent code generation should not be able to tell the
// difference between our synthetic property and a hand-written
// one with the same behavior.
//
for(auto& [key, value] : mapRequiredAccessorToSynAccessor)
{
witnessTable->add(key.getDecl(), RequirementWitness(makeDeclRef(value)));
}
witnessTable->add(requiredMemberDeclRef.getDecl(),
RequirementWitness(makeDeclRef(synPropertyDecl)));
return true;
}
bool SemanticsVisitor::trySynthesizeWrapperTypePropertyRequirementWitness(
ConformanceCheckingContext* context,
DeclRef<PropertyDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
// We are synthesizing a property requirement for a wrapper type:
//
// interface IFoo { property value : int { get; set; } }
// struct Foo : IFoo = FooImpl;
//
// We need to synthesize Foo to:
//
// struct Foo : IFoo
// {
// FooImpl inner;
// property value : int { get { return inner.value; }
// set { inner.value = newValue; }
// }
// }
//
// To do so, we need to grab the witness table of FooImpl:IFoo, and create
// wrapper property in Foo that forwards the accessors to the inner object.
//
// We get started by constructing a synthesized `PropertyDecl`.
//
auto synPropertyDecl = m_astBuilder->create<PropertyDecl>();
synPropertyDecl->parentDecl = context->parentDecl;
// Synthesize the property name with a prefix to avoid name clashing.
//
synPropertyDecl->nameAndLoc = requiredMemberDeclRef.getDecl()->nameAndLoc;
synPropertyDecl->nameAndLoc.name = getName(String("$syn_property_") + getText(requiredMemberDeclRef.getName()));
// Find the witness that FooImpl : IFoo.
auto aggTypeDecl = as<AggTypeDecl>(context->parentDecl);
auto innerType = aggTypeDecl->wrappedType.type;
DeclRef<Decl> innerProperty;
auto innerWitness = tryGetSubtypeWitness(innerType, witnessTable->baseType);
if (!innerWitness)
return false;
for (auto requiredAccessorDeclRef : getMembersOfType<AccessorDecl>(m_astBuilder, requiredMemberDeclRef))
{
auto innerEntry = tryLookUpRequirementWitness(m_astBuilder, innerWitness, requiredAccessorDeclRef.getDecl());
if (innerEntry.getFlavor() != RequirementWitness::Flavor::declRef)
return false;
auto innerAccessorDeclRef = as<AccessorDecl>(innerEntry.getDeclRef());
if (!innerAccessorDeclRef)
return false;
// The synthesized accessor will be an AST node of the same class as
// the required accessor.
//
auto synAccessorDecl = (AccessorDecl*)m_astBuilder->createByNodeType(requiredAccessorDeclRef.getDecl()->astNodeType);
synAccessorDecl->ownedScope = m_astBuilder->create<Scope>();
synAccessorDecl->ownedScope->containerDecl = synAccessorDecl;
synAccessorDecl->ownedScope->parent = getScope(context->parentDecl);
// The return type should be the same as the inner object's accessor return type.
//
synAccessorDecl->returnType.type = getResultType(m_astBuilder, innerAccessorDeclRef);
// Similarly, our synthesized accessor will have parameters matching those of the inner accessor.
//
List<Expr*> synArgs;
for (auto innerParamDeclRef : getParameters(m_astBuilder, innerAccessorDeclRef))
{
auto paramType = getType(m_astBuilder, innerParamDeclRef);
// The synthesized parameter will ahve the same name and
// type as the parameter of the requirement.
//
auto synParamDecl = m_astBuilder->create<ParamDecl>();
synParamDecl->nameAndLoc = innerParamDeclRef.getDecl()->nameAndLoc;
synParamDecl->type.type = paramType;
// We need to add the parameter as a child declaration of
// the accessor we are building.
//
synParamDecl->parentDecl = synAccessorDecl;
synAccessorDecl->members.add(synParamDecl);
// For each paramter, we will create an argument expression
// to represent it in the body of the accessor.
//
auto synArg = m_astBuilder->create<VarExpr>();
synArg->declRef = makeDeclRef(synParamDecl);
synArg->type = paramType;
synArgs.add(synArg);
}
// Now synthesize the body of the property accessor.
// The body of the accessor will depend on the class of the accessor
// we are synthesizing (e.g., `get` vs. `set`).
//
Stmt* synBodyStmt = nullptr;
auto propertyRef = m_astBuilder->create<MemberExpr>();
propertyRef->scope = synAccessorDecl->ownedScope;
auto base = m_astBuilder->create<VarExpr>();
base->scope = propertyRef->scope;
base->name = getName("inner");
propertyRef->baseExpression = base;
innerProperty = innerAccessorDeclRef.getParent();
propertyRef->name = getParentDecl(innerAccessorDeclRef.getDecl())->getName();
auto checkedPropertyRefExpr = CheckExpr(propertyRef);
if (as<GetterDecl>(requiredAccessorDeclRef))
{
auto synReturn = m_astBuilder->create<ReturnStmt>();
synReturn->expression = checkedPropertyRefExpr;
synBodyStmt = synReturn;
}
else if (as<SetterDecl>(requiredAccessorDeclRef))
{
auto synAssign = m_astBuilder->create<AssignExpr>();
synAssign->left = checkedPropertyRefExpr;
synAssign->right = synArgs[0];
auto synCheckedAssign = checkAssignWithCheckedOperands(synAssign);
auto synExprStmt = m_astBuilder->create<ExpressionStmt>();
synExprStmt->expression = synCheckedAssign;
synBodyStmt = synExprStmt;
}
else
{
// While there are other kinds of accessors than `get` and `set`,
// those are currently only reserved for stdlib-internal use.
// We will not bother with synthesis for those cases.
//
return false;
}
addModifier(synAccessorDecl, m_astBuilder->create<ForceInlineAttribute>());
synAccessorDecl->body = synBodyStmt;
synAccessorDecl->parentDecl = synPropertyDecl;
synPropertyDecl->members.add(synAccessorDecl);
// Register the synthesized accessor.
//
witnessTable->add(requiredAccessorDeclRef.getDecl(), RequirementWitness(makeDeclRef(synAccessorDecl)));
}
// The type of our synthesized property will be the same as the inner property.
//
auto propertyType = getType(m_astBuilder, as<PropertyDecl>(innerProperty));
synPropertyDecl->type.type = propertyType;
// The visibility of synthesized decl should be the same as the inner requirement
if (innerProperty.getDecl()->findModifier<VisibilityModifier>())
{
auto vis = getDeclVisibility(innerProperty.getDecl());
addVisibilityModifier(m_astBuilder, synPropertyDecl, vis);
}
context->parentDecl->addMember(synPropertyDecl);
witnessTable->add(requiredMemberDeclRef.getDecl(),
RequirementWitness(makeDeclRef(synPropertyDecl)));
return true;
}
bool SemanticsVisitor::trySynthesizeAssociatedTypeRequirementWitness(
ConformanceCheckingContext* context,
LookupResult const& inLookupResult,
DeclRef<AssocTypeDecl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
SLANG_UNUSED(inLookupResult);
// The only case we can synthesize for now is when the conformant type
// is a wrapper type.
if (!isWrapperTypeDecl(context->parentDecl))
return false;
auto aggTypeDecl = as<AggTypeDecl>(context->parentDecl);
auto lookupResult = lookUpMember(
m_astBuilder,
this,
requiredMemberDeclRef.getName(),
aggTypeDecl->wrappedType.type,
aggTypeDecl->ownedScope,
LookupMask::Default,
LookupOptions::IgnoreBaseInterfaces);
if (!lookupResult.isValid() || lookupResult.isOverloaded())
return false;
auto assocType = DeclRefType::create(m_astBuilder, lookupResult.item.declRef);
witnessTable->add(requiredMemberDeclRef.getDecl(), assocType);
for (auto typeConstraintDecl : getMembersOfType<TypeConstraintDecl>(m_astBuilder, requiredMemberDeclRef))
{
auto witness = tryGetSubtypeWitness(assocType, getSup(m_astBuilder, typeConstraintDecl));
if (!witness)
return false;
witnessTable->add(typeConstraintDecl.getDecl(), witness);
}
return true;
}
bool SemanticsVisitor::trySynthesizeAssociatedConstantRequirementWitness(
ConformanceCheckingContext* context,
LookupResult const& inLookupResult,
DeclRef<VarDeclBase> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
SLANG_UNUSED(inLookupResult);
// The only case we can synthesize for now is when the conformant type
// is a wrapper type, i.e.
// struct Foo:IFoo = FooImpl;
if (!isWrapperTypeDecl(context->parentDecl))
return false;
// Find the witness that FooImpl : IFoo.
auto aggTypeDecl = as<AggTypeDecl>(context->parentDecl);
auto innerType = aggTypeDecl->wrappedType.type;
DeclRef<Decl> innerProperty;
auto innerWitness = tryGetSubtypeWitness(innerType, witnessTable->baseType);
if (!innerWitness)
return false;
auto witness = tryLookUpRequirementWitness(m_astBuilder, innerWitness, requiredMemberDeclRef.getDecl());
if (witness.getFlavor() != RequirementWitness::Flavor::val)
return false;
witnessTable->add(requiredMemberDeclRef.getDecl(), witness.getVal());
return true;
}
bool SemanticsVisitor::trySynthesizeRequirementWitness(
ConformanceCheckingContext* context,
LookupResult const& lookupResult,
DeclRef<Decl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable)
{
SLANG_UNUSED(lookupResult);
SLANG_UNUSED(requiredMemberDeclRef);
SLANG_UNUSED(witnessTable);
if (auto requiredFuncDeclRef = requiredMemberDeclRef.as<FuncDecl>())
{
// Check signature match.
if (trySynthesizeMethodRequirementWitness(
context,
lookupResult,
requiredFuncDeclRef,
witnessTable))
return true;
if (auto builtinAttr = requiredFuncDeclRef.getDecl()->findModifier<BuiltinRequirementModifier>())
{
switch (builtinAttr->kind)
{
case BuiltinRequirementKind::DAddFunc:
case BuiltinRequirementKind::DZeroFunc:
return trySynthesizeDifferentialMethodRequirementWitness(
context,
requiredFuncDeclRef,
witnessTable,
SynthesisPattern::AllInductive);
}
}
return false;
}
// For generic decl, check if we match DMulFunc, and synthesize the method.
if (auto requiredGenericDeclRef = requiredMemberDeclRef.as<GenericDecl>())
{
if (auto builtinAttr = getInner(requiredGenericDeclRef)->findModifier<BuiltinRequirementModifier>())
{
switch (builtinAttr->kind)
{
case BuiltinRequirementKind::DMulFunc:
return trySynthesizeDifferentialMethodRequirementWitness(
context,
requiredGenericDeclRef,
witnessTable,
SynthesisPattern::FixedFirstArg);
}
}
return false;
}
if( auto requiredPropertyDeclRef = requiredMemberDeclRef.as<PropertyDecl>() )
{
return trySynthesizePropertyRequirementWitness(
context,
lookupResult,
requiredPropertyDeclRef,
witnessTable);
}
if (auto requiredAssocTypeDeclRef = requiredMemberDeclRef.as<AssocTypeDecl>())
{
if (auto builtinAttr = requiredAssocTypeDeclRef.getDecl()->findModifier<BuiltinRequirementModifier>())
{
switch (builtinAttr->kind)
{
case BuiltinRequirementKind::DifferentialType:
return trySynthesizeDifferentialAssociatedTypeRequirementWitness(
context,
requiredAssocTypeDeclRef,
witnessTable);
}
}
else
{
return trySynthesizeAssociatedTypeRequirementWitness(
context,
lookupResult,
requiredAssocTypeDeclRef,
witnessTable);
}
}
if (auto requiredConstantDeclRef = requiredMemberDeclRef.as<VarDeclBase>())
{
return trySynthesizeAssociatedConstantRequirementWitness(
context,
lookupResult,
requiredConstantDeclRef,
witnessTable);
}
// TODO: There are other kinds of requirements for which synthesis should
// be possible:
//
// * It should be possible to synthesize required initializers
// using an approach similar to what is used for methods.
//
// * We should be able to synthesize subscripts with different
// signatures (taking into account default parameters).
//
// * For specific kinds of generic requirements, we should be able
// to wrap the synthesis of the inner declaration in synthesis
// of an outer generic with a matching signature.
//
// All of these cases can/should use similar logic to
// `trySynthesizeMethodRequirementWitness` where they construct an AST
// in the form of what the use site ought to look like, and then
// apply existing semantic checking logic to generate the code.
return false;
}
Stmt* _synthesizeMemberAssignMemberHelper(
ASTSynthesizer& synth,
Name* funcName,
Type* leftType,
Expr* leftValue,
List<Expr*>&& args,
List<Expr*>&& genericArgs,
List<bool>&& inductiveArgMask,
int nestingLevel = 0)
{
if (nestingLevel > 16)
return nullptr;
// If field type is an array, assign each element individually.
if (auto arrayType = as<ArrayExpressionType>(leftType))
{
VarDecl* indexVar = nullptr;
auto forStmt = synth.emitFor(synth.emitIntConst(0), synth.emitGetArrayLengthExpr(leftValue), indexVar);
addModifier(forStmt, synth.getBuilder()->create<ForceUnrollAttribute>());
auto innerLeft = synth.emitIndexExpr(leftValue, synth.emitVarExpr(indexVar));
for (auto ii = 0; ii < args.getCount(); ++ii)
{
auto& arg = args[ii];
if (inductiveArgMask[ii])
arg = synth.emitIndexExpr(arg, synth.emitVarExpr(indexVar));
}
auto assignStmt = _synthesizeMemberAssignMemberHelper(
synth,
funcName,
arrayType->getElementType(),
innerLeft,
_Move(args),
_Move(genericArgs),
_Move(inductiveArgMask),
nestingLevel + 1);
synth.popScope();
if (!assignStmt)
return nullptr;
return forStmt;
}
auto callee = synth.emitMemberExpr(leftType, funcName);
if (genericArgs.getCount() > 0)
callee = synth.emitGenericAppExpr(callee, _Move(genericArgs));
return synth.emitAssignStmt(leftValue, synth.emitInvokeExpr(callee, _Move(args)));
}
bool SemanticsVisitor::trySynthesizeDifferentialMethodRequirementWitness(
ConformanceCheckingContext* context,
DeclRef<Decl> requirementDeclRef,
RefPtr<WitnessTable> witnessTable,
SynthesisPattern pattern)
{
// We support two cases of synthesis here.
// Case 1 is that there the associated Differential type is defined to be `DifferentialBottom`.
// In this case we just trivially return `DifferentialBottom` in all synthesized methods.
// Case 2 is that the `Differential` type contains members corresponding to each primal member.
// We will apply a general code synthesis pattern to reflect that structure.
// For requirement of the form:
// ```
// static TResult requiredMethod(TParam1 p0, TParam2 p1, ...)
// ```
// Where TResult,TParam1, TParam2 is either `This` or `Differential`,
// We synthesize a memberwise dispatch to compute each field of `TResult`.
// Multiple patterns are supported (see SemanticsVisitor::SynthesisPattern for a full list)
// For AllInductive, we synthesize an implementation of the form:
// ```
// [BackwardDifferentiable]
// static TResult requiredMethod(TParam1 p0, TParam2 p1, ...)
// {
// TResult result;
// result.member0 = decltype(result.member0).requiredMethod(p0.member0, p1.member0);
// result.member1 = decltype(result.member1).requiredMethod(p0.member1, p1.member1);
// ...
// return result;
// }
// ```
// First we need to make sure the associated `Differential` type requirement is satisfied.
bool hasDifferentialAssocType = false;
for (auto& existingEntry : witnessTable->getRequirementDictionary())
{
if (auto builtinReqAttr = existingEntry.key->findModifier<BuiltinRequirementModifier>())
{
if (builtinReqAttr->kind == BuiltinRequirementKind::DifferentialType &&
existingEntry.value.getFlavor() != RequirementWitness::Flavor::none)
{
hasDifferentialAssocType = true;
}
}
}
if (!hasDifferentialAssocType)
return false;
ASTSynthesizer synth(m_astBuilder, getNamePool());
List<Expr*> synArgs;
List<Expr*> synGenericArgs;
ThisExpr* synThis = nullptr;
FuncDecl* synFunc = nullptr;
GenericDecl* synGeneric = nullptr;
if (auto genericDeclRef = requirementDeclRef.as<GenericDecl>())
{
synGeneric = synthesizeGenericSignatureForRequirementWitness(
context, genericDeclRef, synArgs, synGenericArgs, synThis);
synFunc = as<FuncDecl>(synGeneric->inner);
}
else if (auto funcDeclRef = requirementDeclRef.as<FuncDecl>())
{
synFunc = synthesizeMethodSignatureForRequirementWitness(
context, funcDeclRef, synArgs, synThis);
}
SLANG_ASSERT(synFunc);
addModifier(synFunc, m_astBuilder->create<BackwardDifferentiableAttribute>());
if (synGeneric)
synGeneric->parentDecl = context->parentDecl;
else
synFunc->parentDecl = context->parentDecl;
synth.pushContainerScope(synFunc);
auto blockStmt = m_astBuilder->create<BlockStmt>();
synFunc->body = blockStmt;
auto seqStmt = synth.pushSeqStmtScope();
blockStmt->body = seqStmt;
// Create a variable for return value.
synth.pushVarScope();
auto varStmt = synth.emitVarDeclStmt(synFunc->returnType.type, getName("result"));
auto resultVarExpr = synth.emitVarExpr(varStmt, synFunc->returnType.type);
for (auto member : context->parentDecl->members)
{
auto derivativeAttr = member->findModifier<DerivativeMemberAttribute>();
if (!derivativeAttr)
continue;
auto varMember = as<VarDeclBase>(member);
if (!varMember)
continue;
ensureDecl(varMember, DeclCheckState::ReadyForReference);
auto memberType = varMember->getType();
auto diffMemberType = tryGetDifferentialType(m_astBuilder, memberType);
if (!diffMemberType)
continue;
// Construct reference exprs to the member's corresponding fields in each parameter.
List<Expr*> paramFields;
List<bool> inductiveArgMask;
switch (pattern)
{
case SynthesisPattern::AllInductive:
{
for (auto arg : synArgs)
{
auto memberExpr = m_astBuilder->create<MemberExpr>();
memberExpr->baseExpression = arg;
// TODO: we should probably fetch the name from `[DerivativeMember]` if `arg` is
// Differential type.
memberExpr->name = varMember->getName();
paramFields.add(memberExpr);
inductiveArgMask.add(true);
}
break;
}
case SynthesisPattern::FixedFirstArg:
{
int paramIndex = 0;
for (auto arg : synArgs)
{
if (paramIndex == 0)
{
paramFields.add(arg);
inductiveArgMask.add(false);
paramIndex++;
}
else
{
auto memberExpr = m_astBuilder->create<MemberExpr>();
memberExpr->baseExpression = arg;
// TODO: we should probably fetch the name from `[DerivativeMember]` if `arg` is
// Differential type.
memberExpr->name = varMember->getName();
paramFields.add(memberExpr);
inductiveArgMask.add(true);
paramIndex++;
}
}
break;
}
default:
SLANG_UNIMPLEMENTED_X("unhandled synthesis pattern");
break;
}
// Invoke the method for the field and assign the value to resultVar.
// TODO: we should probably fetch the name from `[DerivativeMember]` if `resultVarExpr`
// is Differential type.
auto leftVal = synth.emitMemberExpr(resultVarExpr, varMember->getName());
if (!_synthesizeMemberAssignMemberHelper(
synth,
requirementDeclRef.getName(),
memberType,
leftVal,
_Move(paramFields),
_Move(synGenericArgs),
_Move(inductiveArgMask)))
return false;
}
// TODO: synthesize assignments for inherited members here.
auto synReturn = m_astBuilder->create<ReturnStmt>();
synReturn->expression = resultVarExpr;
seqStmt->stmts.add(synReturn);
context->parentDecl->members.add(synFunc);
context->parentDecl->invalidateMemberDictionary();
addModifier(synFunc, m_astBuilder->create<SynthesizedModifier>());
// If `This` is nested inside a generic, we need to form a complete declref type to the
// newly synthesized method here in order to fill into the witness table.
// This can be done by obtaining the ThisType witness from requirementDeclRef to get the
// generic substitution for outer generic parameters, and apply it here.
SubstitutionSet substSet;
if (auto thisTypeWitness = findThisTypeWitness(
SubstitutionSet(requirementDeclRef),
as<InterfaceDecl>(requirementDeclRef.getDecl()->parentDecl)))
{
if (auto declRefType = as<DeclRefType>(thisTypeWitness->getSub()))
{
substSet = SubstitutionSet(declRefType->getDeclRef());
}
}
if (auto outerGeneric = GetOuterGeneric(context->parentDecl))
{
// If the context->parentDecl is not the same as ThisType represented by genApp, then it must be an extension
// to ThisType. In this case, we need to form a new GenericAppDeclRef to specailizethe outer parent extension
// decl. Note that the extension might be a partial extension with some generic arguments missing, and
// we can't support that case right now. For now we can just assume the extension will have the same set
// of generic parameters as the target type.
auto defaultArgs = getDefaultSubstitutionArgs(m_astBuilder, this, outerGeneric);
auto specializedParent = m_astBuilder->getGenericAppDeclRef(makeDeclRef(outerGeneric), defaultArgs.getArrayView());
auto specializedFunc = m_astBuilder->getMemberDeclRef(specializedParent, synFunc);
witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(specializedFunc));
return true;
}
witnessTable->add(requirementDeclRef.getDecl(), RequirementWitness(m_astBuilder->getDirectDeclRef(synFunc)));
return true;
}
bool SemanticsVisitor::findWitnessForInterfaceRequirement(
ConformanceCheckingContext* context,
Type* subType,
Type* superInterfaceType,
InheritanceDecl* inheritanceDecl,
DeclRef<InterfaceDecl> superInterfaceDeclRef,
DeclRef<Decl> requiredMemberDeclRef,
RefPtr<WitnessTable> witnessTable,
SubtypeWitness* subTypeConformsToSuperInterfaceWitness)
{
SLANG_UNUSED(superInterfaceDeclRef)
// The goal of this function is to find a suitable
// value to satisfy the requirement.
//
// The 99% case is that the requirement is a named member
// of the interface, and we need to search for a member
// with the same name in the type declaration and
// its (known) extensions.
// As a first pass, lets check if we already have a
// witness in the table for the requirement, so
// that we can bail out early.
//
if(witnessTable->getRequirementDictionary().containsKey(requiredMemberDeclRef.getDecl()))
{
return true;
}
// The ThisType requirement is always satisfied.
if (as<ThisTypeDecl>(requiredMemberDeclRef.getDecl()))
{
return true;
}
// An important exception to the above is that an
// inheritance declaration in the interface is not going
// to be satisfied by an inheritance declaration in the
// conforming type, but rather by a full "witness table"
// full of the satisfying values for each requirement
// in the inherited-from interface.
//
if( auto requiredInheritanceDeclRef = requiredMemberDeclRef.as<InheritanceDecl>() )
{
// Recursively check that the type conforms
// to the inherited interface.
//
// TODO: we *really* need a linearization step here!!!!
auto reqType = getBaseType(m_astBuilder, requiredInheritanceDeclRef);
auto interfaceIsReqWitness =
m_astBuilder->getDeclaredSubtypeWitness(
superInterfaceType,
reqType,
requiredInheritanceDeclRef);
// ...
auto subIsReqWitness = m_astBuilder->getTransitiveSubtypeWitness(
subTypeConformsToSuperInterfaceWitness,
interfaceIsReqWitness);
// ...
RefPtr<WitnessTable> satisfyingWitnessTable = new WitnessTable();
satisfyingWitnessTable->witnessedType = subType;
satisfyingWitnessTable->baseType = reqType;
witnessTable->add(
requiredInheritanceDeclRef.getDecl(),
RequirementWitness(satisfyingWitnessTable));
if( !checkConformanceToType(
context,
subType,
requiredInheritanceDeclRef.getDecl(),
reqType,
subIsReqWitness,
satisfyingWitnessTable) )
{
return false;
}
return true;
}
// We will look up members with the same name,
// since only same-name members will be able to
// satisfy the requirement.
//
Name* name = requiredMemberDeclRef.getName();
// We start by looking up members of the same
// name, on the type that is claiming to conform.
//
// This lookup step could include members that
// we might not actually want to consider:
//
// * Lookup through a type `Foo` where `Foo : IBar`
// will be able to find members of `IBar`, which
// somewhat obviously shouldn't apply when
// determining if `Foo` satisfies the requirements
// of `IBar`.
//
// * Lookup in the presence of `__transparent` members
// may produce references to declarations on a *field*
// of the type rather than the type. Conformance through
// transparent members could be supported in theory,
// but would require synthesizing proxy/forwarding
// implementations in the type itself.
//
// For the first issue, we will use a flag to influence
// lookup so that it doesn't include results looked up
// through interface inheritance clauses (but it *will*
// look up result through inheritance clauses corresponding
// to concrete types).
//
// The second issue of members that require us to proxy/forward
// requests will be handled further down. For now we include
// lookup results that might be usable, but not as-is.
//
LookupResult lookupResult;
if (!isWrapperTypeDecl(context->parentDecl))
{
lookupResult = lookUpMember(m_astBuilder, this, name, subType, nullptr, LookupMask::Default, LookupOptions::IgnoreBaseInterfaces);
if (!lookupResult.isValid())
{
// If we failed to look up a member with the name of the
// requirement, it may be possible that we can still synthesis the
// implementation if this is one of the known builtin requirements.
// Otherwise, report diagnostic now.
if (!requiredMemberDeclRef.getDecl()->hasModifier<BuiltinRequirementModifier>() &&
!(requiredMemberDeclRef.as<GenericDecl>() &&
getInner(requiredMemberDeclRef.as<GenericDecl>())->hasModifier<BuiltinRequirementModifier>()))
{
getSink()->diagnose(inheritanceDecl, Diagnostics::typeDoesntImplementInterfaceRequirement, subType, requiredMemberDeclRef);
getSink()->diagnose(requiredMemberDeclRef, Diagnostics::seeDeclarationOf, requiredMemberDeclRef);
return false;
}
}
}
// Iterate over the members and look for one that matches
// the expected signature for the requirement.
for (auto member : lookupResult)
{
// To a first approximation, any lookup result that required a "breadcrumb"
// will not be usable to directly satisfy an interface requirement, since
// each breadcrumb will amount to a manipulation of `this` that is required
// to make the declaration usable (e.g., casting to a base type).
//
if(member.breadcrumbs != nullptr)
continue;
if (doesMemberSatisfyRequirement(member.declRef, requiredMemberDeclRef, witnessTable))
{
// The member satisfies the requirement in every other way except that
// it may have a lower visibility than min(parentVisibility, requirementVisibilty),
// in that case we will treat it as an error.
auto minRequiredVisibility = Math::Min(getDeclVisibility(requiredMemberDeclRef.getDecl()), getTypeVisibility(subType));
if (getDeclVisibility(member.declRef.getDecl()) < minRequiredVisibility)
{
getSink()->diagnose(member.declRef, Diagnostics::satisfyingDeclCannotHaveLowerVisibility, member.declRef);
getSink()->diagnose(requiredMemberDeclRef, Diagnostics::seeDeclarationOf, QualifiedDeclPath(requiredMemberDeclRef));
return false;
}
return true;
}
}
// If we reach this point then there were no members suitable
// for satisfying the interface requirement *diretly*.
//
// It is possible that one of the items in `lookupResult` could be
// used to synthesize an exact-match witness, by generating the
// code required to handle all the conversions that might be
// required on `this`.
//
// Another situation that will get us here is that we are dealing with
// a wrapper type (struct Foo:IFoo=FooImpl), and we will synthesize
// wrappers that redirects the call into the inner element.
//
if( trySynthesizeRequirementWitness(context, lookupResult, requiredMemberDeclRef, witnessTable) )
{
return true;
}
// We failed to find a member of the type that can be used
// to satisfy the requirement (even via synthesis), so we
// need to report the failure to the user.
//
// TODO: Eventually we might want something akin to the current
// overload resolution logic, where we keep track of a list
// of "candidates" for satisfaction of the requirement,
// and if nothing is found we print the candidates that made it
// furthest in checking.
//
if (!lookupResult.isOverloaded() && lookupResult.isValid())
{
getSink()->diagnose(lookupResult.item.declRef, Diagnostics::memberDoesNotMatchRequirementSignature, lookupResult.item.declRef);
}
else
{
getSink()->diagnose(inheritanceDecl, Diagnostics::typeDoesntImplementInterfaceRequirement, subType, requiredMemberDeclRef);
}
getSink()->diagnose(requiredMemberDeclRef, Diagnostics::seeDeclarationOfInterfaceRequirement, requiredMemberDeclRef);
return false;
}
RefPtr<WitnessTable> SemanticsVisitor::checkInterfaceConformance(
ConformanceCheckingContext* context,
Type* subType,
Type* superInterfaceType,
InheritanceDecl* inheritanceDecl,
DeclRef<InterfaceDecl> superInterfaceDeclRef,
SubtypeWitness* subTypeConformsToSuperInterfaceWitnes)
{
// Has somebody already checked this conformance,
// and/or is in the middle of checking it?
RefPtr<WitnessTable> witnessTable;
if(context->mapInterfaceToWitnessTable.tryGetValue(superInterfaceDeclRef, witnessTable))
return witnessTable;
// We need to check the declaration of the interface
// before we can check that we conform to it.
//
ensureDecl(superInterfaceDeclRef, DeclCheckState::CanReadInterfaceRequirements);
// We will construct the witness table, and register it
// *before* we go about checking fine-grained requirements,
// in order to short-circuit any potential for infinite recursion.
// Note: we will re-use the witnes table attached to the inheritance decl,
// if there is one. This catches cases where semantic checking might
// have synthesized some of the conformance witnesses for us.
//
witnessTable = inheritanceDecl->witnessTable;
if(!witnessTable)
{
witnessTable = new WitnessTable();
witnessTable->baseType = DeclRefType::create(m_astBuilder, superInterfaceDeclRef);
witnessTable->witnessedType = subType;
}
context->mapInterfaceToWitnessTable.add(superInterfaceDeclRef, witnessTable);
if(!checkInterfaceConformance(context, subType, superInterfaceType, inheritanceDecl, superInterfaceDeclRef, subTypeConformsToSuperInterfaceWitnes, witnessTable))
return nullptr;
return witnessTable;
}
static bool isAssociatedTypeDecl(Decl* decl)
{
auto d = decl;
while(auto genericDecl = as<GenericDecl>(d))
d = genericDecl->inner;
if(as<AssocTypeDecl>(d))
return true;
return false;
}
bool SemanticsVisitor::checkInterfaceConformance(
ConformanceCheckingContext* context,
Type* subType,
Type* superInterfaceType,
InheritanceDecl* inheritanceDecl,
DeclRef<InterfaceDecl> superInterfaceDeclRef,
SubtypeWitness* subTypeConformsToSuperInterfaceWitness,
WitnessTable* witnessTable)
{
// We need to check the declaration of the interface
// before we can check that we conform to it.
//
ensureDecl(superInterfaceDeclRef, DeclCheckState::CanReadInterfaceRequirements);
// When comparing things like signatures, we need to do so in the context
// of a LookupDeclRef that aligns the signatures in the interface
// with those in the concrete type. For example, we need to treat any uses
// of `This` in the interface as equivalent to the concrete type for the
// purpose of signature matching (and similarly for associated types).
//
auto thisTypeDeclRef = m_astBuilder->getLookupDeclRef(
subTypeConformsToSuperInterfaceWitness, superInterfaceDeclRef.getDecl()->getThisTypeDecl());
bool result = true;
// TODO: If we ever allow for implementation inheritance,
// then we will need to consider the case where a type
// declares that it conforms to an interface, but one of
// its (non-interface) base types already conforms to
// that interface, so that all of the requirements are
// already satisfied with inherited implementations...
// Note: we break this logic into two loops, where we first
// check conformance for all associated-type requirements
// and *then* check conformance for all other requirements.
//
// Checking associated-type requirements first ensures that
// we can make use of the identity of the associated types
// when checking other members.
//
// TODO: There could in theory be subtle cases involving
// circular or recursive dependency chains that make such
// a simple ordering impractical (e.g., associated type `A`
// is constrained to `IThing<This>` where `IThing<T>` requires
// that `T : IOtherThing where T.B == int` for another associated
// type `B`).
//
// The only robust solution long-term is probably to treat this
// as a type-inference problem by creating type variables to
// stand in for the associated-type requirements and then to discover
// constraints and solve for those type variables as part of the
// conformance-checking process.
//
for(auto requiredMemberDecl : getMembers(m_astBuilder, superInterfaceDeclRef))
{
if(!isAssociatedTypeDecl(requiredMemberDecl.getDecl()))
continue;
auto requiredMemberDeclRef = m_astBuilder->getLookupDeclRef(subTypeConformsToSuperInterfaceWitness, requiredMemberDecl.getDecl());
auto requirementSatisfied = findWitnessForInterfaceRequirement(
context,
subType,
superInterfaceType,
inheritanceDecl,
thisTypeDeclRef,
requiredMemberDeclRef,
witnessTable,
subTypeConformsToSuperInterfaceWitness);
result = result && requirementSatisfied;
}
for(auto requiredMemberDecl : getMembers(m_astBuilder, superInterfaceDeclRef))
{
if(isAssociatedTypeDecl(requiredMemberDecl.getDecl()))
continue;
if (requiredMemberDecl.as<DerivativeRequirementDecl>())
continue;
auto requiredMemberDeclRef = m_astBuilder->getLookupDeclRef(subTypeConformsToSuperInterfaceWitness, requiredMemberDecl.getDecl());
auto requirementSatisfied = findWitnessForInterfaceRequirement(
context,
subType,
superInterfaceType,
inheritanceDecl,
thisTypeDeclRef,
requiredMemberDeclRef,
witnessTable,
subTypeConformsToSuperInterfaceWitness);
result = result && requirementSatisfied;
}
// Extensions that apply to the interface type can create new conformances
// for the concrete types that inherit from the interface.
//
// These new conformances should not be able to introduce new *requirements*
// for an implementing interface (although they currently can), but we
// still need to go through this logic to find the appropriate value
// that will satisfy the requirement in these cases, and also to put
// the required entry into the witness table for the interface itself.
//
// TODO: This logic is a bit slippery, and we need to figure out what
// it means in the context of separate compilation. If module A defines
// an interface IA, module B defines a type C that conforms to IA, and then
// module C defines an extension that makes IA conform to IC, then it is
// unreasonable to expect the {B:IA} witness table to contain an entry
// corresponding to {IA:IC}.
//
// The simple answer then would be that the {IA:IC} conformance should be
// fixed, with a single witness table for {IA:IC}, but then what should
// happen in B explicitly conformed to IC already?
//
// For now we will just walk through the extensions that are known at
// the time we are compiling and handle those, and punt on the larger issue
// for a bit longer.
//
for(auto candidateExt : getCandidateExtensions(superInterfaceDeclRef, this))
{
// We need to apply the extension to the interface type that our
// concrete type is inheriting from.
//
Type* targetType = DeclRefType::create(m_astBuilder, thisTypeDeclRef);
auto parentDeclRef = applyExtensionToType(candidateExt, targetType);
if(!parentDeclRef)
continue;
// Only inheritance clauses from the extension matter right now.
for(auto requiredInheritanceDecl : getMembersOfType<InheritanceDecl>(m_astBuilder, candidateExt))
{
auto requiredInheritanceDeclRef = m_astBuilder->getLookupDeclRef(
subTypeConformsToSuperInterfaceWitness, requiredInheritanceDecl.getDecl());
auto requirementSatisfied = findWitnessForInterfaceRequirement(
context,
subType,
superInterfaceType,
inheritanceDecl,
thisTypeDeclRef,
requiredInheritanceDeclRef,
witnessTable,
subTypeConformsToSuperInterfaceWitness);
result = result && requirementSatisfied;
}
}
// The conformance was satisfied if all the requirements were satisfied.
//
return result;
}
bool SemanticsVisitor::checkConformanceToType(
ConformanceCheckingContext* context,
Type* subType,
InheritanceDecl* inheritanceDecl,
Type* superType,
SubtypeWitness* subIsSuperWitness,
WitnessTable* witnessTable)
{
if (witnessTable->isExtern)
return true;
if (auto supereclRefType = as<DeclRefType>(superType))
{
auto superTypeDeclRef = supereclRefType->getDeclRef();
if (auto superInterfaceDeclRef = superTypeDeclRef.as<InterfaceDecl>())
{
// The type is stating that it conforms to an interface.
// We need to check that it provides all of the members
// required by that interface.
return checkInterfaceConformance(
context,
subType,
superType,
inheritanceDecl,
superInterfaceDeclRef,
subIsSuperWitness,
witnessTable);
}
else if( auto superStructDeclRef = superTypeDeclRef.as<StructDecl>() )
{
// The type is saying it inherits from a `struct`,
// which doesn't require any checking at present
return true;
}
}
if (!as<ErrorType>(superType))
{
getSink()->diagnose(
inheritanceDecl,
Diagnostics::invalidTypeForInheritance,
superType);
}
return false;
}
static bool _doesTypeDeclHaveDefinition(ContainerDecl* decl)
{
if (auto aggTypeDecl = as<AggTypeDecl>(decl))
return aggTypeDecl->hasBody;
return false;
}
bool SemanticsVisitor::checkConformance(
Type* subType,
InheritanceDecl* inheritanceDecl,
ContainerDecl* parentDecl)
{
auto superType = inheritanceDecl->base.type;
if( auto declRefType = as<DeclRefType>(subType) )
{
auto declRef = declRefType->getDeclRef();
if (auto superDeclRefType = as<DeclRefType>(superType))
{
auto superTypeDecl = superDeclRefType->getDeclRef().getDecl();
if (superTypeDecl->findModifier<ComInterfaceAttribute>())
{
// A struct cannot implement a COM Interface.
if (auto classDecl = as<ClassDecl>(superTypeDecl))
{
// OK.
SLANG_UNUSED(classDecl);
}
else if (auto subInterfaceDecl = as<InterfaceDecl>(superTypeDecl))
{
if (!subInterfaceDecl->findModifier<ComInterfaceAttribute>())
{
getSink()->diagnose(inheritanceDecl, Diagnostics::interfaceInheritingComMustBeCom);
}
}
else if (const auto structDecl = as<StructDecl>(superTypeDecl))
{
getSink()->diagnose(inheritanceDecl, Diagnostics::structCannotImplementComInterface);
}
}
}
// Don't check conformances for abstract types that
// are being used to express *required* conformances.
if (auto assocTypeDeclRef = declRef.as<AssocTypeDecl>())
{
// An associated type declaration represents a requirement
// in an outer interface declaration, and its members
// (type constraints) represent additional requirements.
return true;
}
else if (auto interfaceDeclRef = declRef.as<InterfaceDecl>())
{
// HACK: Our semantics as they stand today are that an
// `extension` of an interface that adds a new inheritance
// clause acts *as if* that inheritnace clause had been
// attached to the original `interface` decl: that is,
// it adds additional requirements.
//
// This is *not* a reasonable semantic to keep long-term,
// but it is required for some of our current example
// code to work.
return true;
}
}
// Look at the type being inherited from, and validate
// appropriately.
DeclaredSubtypeWitness* subIsSuperWitness = m_astBuilder->getDeclaredSubtypeWitness(subType, superType, makeDeclRef(inheritanceDecl));
ConformanceCheckingContext context;
context.conformingType = subType;
context.parentDecl = parentDecl;
RefPtr<WitnessTable> witnessTable = inheritanceDecl->witnessTable;
if(!witnessTable)
{
witnessTable = new WitnessTable();
witnessTable->baseType = superType;
witnessTable->witnessedType = subType;
witnessTable->isExtern = (!_doesTypeDeclHaveDefinition(parentDecl)
&& parentDecl->hasModifier<ExternModifier>());
inheritanceDecl->witnessTable = witnessTable;
}
if( !checkConformanceToType(&context, subType, inheritanceDecl, superType, subIsSuperWitness, witnessTable) )
{
return false;
}
return true;
}
void SemanticsVisitor::checkExtensionConformance(ExtensionDecl* decl)
{
auto declRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(decl)).as<ExtensionDecl>();
auto targetType = getTargetType(m_astBuilder, declRef);
for (auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>())
{
checkConformance(targetType, inheritanceDecl, decl);
}
}
void SemanticsVisitor::checkAggTypeConformance(AggTypeDecl* decl)
{
// After we've checked members, we need to go through
// any inheritance clauses on the type itself, and
// confirm that the type actually provides whatever
// those clauses require.
if (const auto interfaceDecl = as<InterfaceDecl>(decl))
{
// Don't check that an interface conforms to the
// things it inherits from.
}
else if (const auto assocTypeDecl = as<AssocTypeDecl>(decl))
{
// Don't check that an associated type decl conforms to the
// things it inherits from.
}
else
{
// For non-interface types we need to check conformance.
//
auto astBuilder = getASTBuilder();
auto declRef = createDefaultSubstitutionsIfNeeded(astBuilder, this, makeDeclRef(decl)).as<AggTypeDeclBase>();
auto type = DeclRefType::create(astBuilder, declRef);
// TODO: Need to figure out what this should do for
// `abstract` types if we ever add them. Should they
// be required to implement all interface requirements,
// just with `abstract` methods that replicate things?
// (That's what C# does).
// Make a copy of inhertanceDecls firstsince `checkConformance` may modify decl->members.
auto inheritanceDecls = decl->getMembersOfType<InheritanceDecl>().toList();
for (auto inheritanceDecl : inheritanceDecls)
{
checkConformance(type, inheritanceDecl, decl);
}
}
}
void SemanticsDeclBasesVisitor::_validateCrossModuleInheritance(
AggTypeDeclBase* decl,
InheritanceDecl* inheritanceDecl)
{
// Within a single module, users should be allowed to inherit
// one type from another more or less freely, so long as they
// don't violate fundamental validity conditions around
// inheritance.
//
// When an inheritance relationship is declared in one module,
// and the base type is in another module, we may want to
// enforce more restrictions. As a strong example, we probably
// don't want people to declare their own subtype of `int`
// or `Texture2D<float4>`.
//
// We start by checking if the type being inherited from is
// a decl-ref type, since that means it refers to a declaration
// that can be localized to its original module.
//
auto baseType = inheritanceDecl->base.type;
auto baseDeclRefType = as<DeclRefType>(baseType);
if( !baseDeclRefType )
{
return;
}
auto baseDecl = baseDeclRefType->getDeclRef().getDecl();
// Using the parent/child hierarchy baked into `Decl`s we
// can find the modules that contain both the `decl` doing
// the inheriting, and the `baseDeclRefType` that is being
// inherited from.
//
// If those modules are the same, then we aren't seeing any
// kind of cross-module inheritance here, and there is nothing
// that needs enforcing.
//
auto moduleWithInheritance = getModule(decl);
auto moduleWithBaseType = getModule(baseDecl);
if( moduleWithInheritance == moduleWithBaseType )
{
return;
}
if( baseDecl->hasModifier<SealedAttribute>() )
{
// If the original declaration had the `[sealed]` attribute on it,
// then it explicitly does *not* allow inheritance from other
// modules.
//
getSink()->diagnose(inheritanceDecl, Diagnostics::cannotInheritFromExplicitlySealedDeclarationInAnotherModule, baseType, moduleWithBaseType->getModuleDecl()->getName());
return;
}
else if( baseDecl->hasModifier<OpenAttribute>() )
{
// Conversely, if the original declaration had the `[open]` attribute
// on it, then it explicit *does* allow inheritance from other
// modules.
//
// In this case we don't need to check anything: the inheritance
// is allowed.
}
else if( as<InterfaceDecl>(baseDecl) )
{
// If an interface isn't explicitly marked `[open]` or `[sealed]`,
// then the default behavior is to treat it as `[open]`, since
// interfaces are most often used to define protocols that
// users of a module can opt into.
}
else
{
// For any non-interface type, if the declaration didn't specify
// `[open]` or `[sealed]` then we assume `[sealed]` is the default.
//
getSink()->diagnose(inheritanceDecl, Diagnostics::cannotInheritFromImplicitlySealedDeclarationInAnotherModule, baseType, moduleWithBaseType->getModuleDecl()->getName());
return;
}
}
void SemanticsDeclBasesVisitor::visitInterfaceDecl(InterfaceDecl* decl)
{
SLANG_OUTER_SCOPE_CONTEXT_DECL_RAII(this, decl);
checkVisibility(decl);
for( auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>() )
{
ensureDecl(inheritanceDecl, DeclCheckState::CanUseBaseOfInheritanceDecl);
auto baseType = inheritanceDecl->base.type;
// It is possible that there was an error in checking the base type
// expression, and in such a case we shouldn't emit a cascading error.
//
if( const auto baseErrorType = as<ErrorType>(baseType) )
{
continue;
}
// An `interface` type can only inherit from other `interface` types.
//
// TODO: In the long run it might make sense for an interface to support
// an inheritance clause naming a non-interface type, with the meaning
// that any type that implements the interface must be a sub-type of the
// type named in the inheritance clause.
//
auto baseDeclRefType = as<DeclRefType>(baseType);
if( !baseDeclRefType )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfInterfaceMustBeInterface, decl, baseType);
continue;
}
auto baseDeclRef = baseDeclRefType->getDeclRef();
auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>();
if( !baseInterfaceDeclRef )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfInterfaceMustBeInterface, decl, baseType);
continue;
}
// TODO: At this point we have the `baseInterfaceDeclRef`
// and could use it to perform further validity checks,
// and/or to build up a more refined representation of
// the inheritance graph for this type (e.g., a "class
// precedence list").
//
// E.g., we can/should check that we aren't introducing
// a circular inheritance relationship.
_validateCrossModuleInheritance(decl, inheritanceDecl);
}
if (decl->findModifier<ComInterfaceAttribute>())
{
// `associatedtype` declaration is not allowed in a COM interface declaration.
for (auto associatedType : decl->getMembersOfType<AssocTypeDecl>())
{
getSink()->diagnose(
associatedType, Diagnostics::associatedTypeNotAllowInComInterface);
}
}
}
void SemanticsDeclBasesVisitor::visitStructDecl(StructDecl* decl)
{
// A `struct` type can only inherit from `struct` or `interface` types.
//
// Furthermore, only the first inheritance clause (in source
// order) is allowed to declare a base `struct` type.
//
SLANG_OUTER_SCOPE_CONTEXT_DECL_RAII(this, decl);
Index inheritanceClauseCounter = 0;
for( auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>() )
{
Index inheritanceClauseIndex = inheritanceClauseCounter++;
ensureDecl(inheritanceDecl, DeclCheckState::CanUseBaseOfInheritanceDecl);
auto baseType = inheritanceDecl->base.type;
// It is possible that there was an error in checking the base type
// expression, and in such a case we shouldn't emit a cascading error.
//
if( const auto baseErrorType = as<ErrorType>(baseType) )
{
continue;
}
auto baseDeclRefType = as<DeclRefType>(baseType);
if( !baseDeclRefType )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfStructMustBeStructOrInterface, decl, baseType);
continue;
}
auto baseDeclRef = baseDeclRefType->getDeclRef();
if( auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>() )
{
}
else if( auto baseStructDeclRef = baseDeclRef.as<StructDecl>() )
{
// To simplify the task of reading and maintaining code,
// we require that when a `struct` inherits from another
// `struct`, the base `struct` is the first item in
// the list of bases (before any interfaces).
//
// This constraint also has the secondary effect of restricting
// it so that a `struct` cannot multiply inherit from other
// `struct` types.
//
if( inheritanceClauseIndex != 0 )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseStructMustBeListedFirst, decl, baseType);
}
}
else
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfStructMustBeStructOrInterface, decl, baseType);
continue;
}
// TODO: At this point we have the `baseDeclRef`
// and could use it to perform further validity checks,
// and/or to build up a more refined representation of
// the inheritance graph for this type (e.g., a "class
// precedence list").
//
// E.g., we can/should check that we aren't introducing
// a circular inheritance relationship.
_validateCrossModuleInheritance(decl, inheritanceDecl);
}
}
void SemanticsDeclBasesVisitor::visitClassDecl(ClassDecl* decl)
{
// A `class` type can only inherit from `class` or `interface` types.
//
// Furthermore, only the first inheritance clause (in source
// order) is allowed to declare a base `class` type.
//
SLANG_OUTER_SCOPE_CONTEXT_DECL_RAII(this, decl);
Index inheritanceClauseCounter = 0;
for (auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>())
{
Index inheritanceClauseIndex = inheritanceClauseCounter++;
ensureDecl(inheritanceDecl, DeclCheckState::CanUseBaseOfInheritanceDecl);
auto baseType = inheritanceDecl->base.type;
// It is possible that there was an error in checking the base type
// expression, and in such a case we shouldn't emit a cascading error.
//
if (const auto baseErrorType = as<ErrorType>(baseType))
{
continue;
}
auto baseDeclRefType = as<DeclRefType>(baseType);
if (!baseDeclRefType)
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfClassMustBeClassOrInterface, decl, baseType);
continue;
}
auto baseDeclRef = baseDeclRefType->getDeclRef();
if (auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>())
{
}
else if (auto baseStructDeclRef = baseDeclRef.as<ClassDecl>())
{
// To simplify the task of reading and maintaining code,
// we require that when a `class` inherits from another
// `class`, the base `class` is the first item in
// the list of bases (before any interfaces).
//
// This constraint also has the secondary effect of restricting
// it so that a `struct` cannot multiply inherit from other
// `struct` types.
//
if (inheritanceClauseIndex != 0)
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseClassMustBeListedFirst, decl, baseType);
}
}
else
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfClassMustBeClassOrInterface, decl, baseType);
continue;
}
// TODO: At this point we have the `baseDeclRef`
// and could use it to perform further validity checks,
// and/or to build up a more refined representation of
// the inheritance graph for this type (e.g., a "class
// precedence list").
//
// E.g., we can/should check that we aren't introducing
// a circular inheritance relationship.
_validateCrossModuleInheritance(decl, inheritanceDecl);
}
}
bool SemanticsVisitor::isIntegerBaseType(BaseType baseType)
{
return (BaseTypeInfo::getInfo(baseType).flags & BaseTypeInfo::Flag::Integer) != 0;
}
bool SemanticsVisitor::isScalarIntegerType(Type* type)
{
auto basicType = as<BasicExpressionType>(type);
if(!basicType)
return false;
auto baseType = basicType->getBaseType();
return isIntegerBaseType(baseType) || baseType == BaseType::Bool;
}
bool SemanticsVisitor::isIntValueInRangeOfType(IntegerLiteralValue value, Type* type)
{
auto basicType = as<BasicExpressionType>(type);
if (!basicType)
return false;
switch (basicType->getBaseType())
{
case BaseType::UInt8:
return (value >= 0 && value <= std::numeric_limits<uint8_t>::max()) || (value == -1);
case BaseType::UInt16:
return (value >= 0 && value <= std::numeric_limits<uint16_t>::max()) || (value == -1);
case BaseType::UInt:
#if SLANG_PTR_IS_32
case BaseType::UIntPtr:
#endif
return (value >= 0 && value <= std::numeric_limits<uint32_t>::max()) || (value == -1);
case BaseType::UInt64:
#if SLANG_PTR_IS_64
case BaseType::UIntPtr:
#endif
return true;
case BaseType::Int8:
return value >= std::numeric_limits<int8_t>::min() && value <= std::numeric_limits<int8_t>::max();
case BaseType::Int16:
return value >= std::numeric_limits<int16_t>::min() && value <= std::numeric_limits<int16_t>::max();
case BaseType::Int:
#if SLANG_PTR_IS_32
case BaseType::IntPtr:
#endif
return value >= std::numeric_limits<int32_t>::min() && value <= std::numeric_limits<int32_t>::max();
case BaseType::Int64:
#if SLANG_PTR_IS_64
case BaseType::IntPtr:
#endif
return value >= std::numeric_limits<int64_t>::min() && value <= std::numeric_limits<int64_t>::max();
default:
return false;
}
}
void SemanticsVisitor::validateEnumTagType(Type* type, SourceLoc const& loc)
{
// Allow the built-in integer types.
//
if(isScalarIntegerType(type))
return;
// By default, don't allow other types to be used
// as an `enum` tag type.
//
getSink()->diagnose(loc, Diagnostics::invalidEnumTagType, type);
}
void SemanticsDeclBasesVisitor::visitEnumDecl(EnumDecl* decl)
{
SLANG_OUTER_SCOPE_CONTEXT_DECL_RAII(this, decl);
checkVisibility(decl);
// An `enum` type can inherit from interfaces, and also
// from a single "tag" type that must:
//
// * be a built-in integer type
// * come first in the list of base types
//
Index inheritanceClauseCounter = 0;
Type* tagType = nullptr;
InheritanceDecl* tagTypeInheritanceDecl = nullptr;
for(auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>())
{
Index inheritanceClauseIndex = inheritanceClauseCounter++;
ensureDecl(inheritanceDecl, DeclCheckState::CanUseBaseOfInheritanceDecl);
auto baseType = inheritanceDecl->base.type;
// It is possible that there was an error in checking the base type
// expression, and in such a case we shouldn't emit a cascading error.
//
if( const auto baseErrorType = as<ErrorType>(baseType) )
{
continue;
}
auto baseDeclRefType = as<DeclRefType>(baseType);
if( !baseDeclRefType )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfEnumMustBeIntegerOrInterface, decl, baseType);
continue;
}
auto baseDeclRef = baseDeclRefType->getDeclRef();
if( auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>() )
{
_validateCrossModuleInheritance(decl, inheritanceDecl);
}
else if( auto baseStructDeclRef = baseDeclRef.as<StructDecl>() )
{
// To simplify the task of reading and maintaining code,
// we require that when an `enum` declares an explicit
// underlying tag type using an inheritance clause, that
// type must be the first item in the list of bases.
//
// This constraint also has the secondary effect of restricting
// it so that an `enum` can't possibly have multiple tag
// types declared.
//
if( inheritanceClauseIndex != 0 )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::tagTypeMustBeListedFirst, decl, baseType);
}
else
{
tagType = baseType;
tagTypeInheritanceDecl = inheritanceDecl;
}
// Note: we do *not* apply the code that validates
// cross-module inheritance to a base that represnts
// a tag type, because declaring a tag type for an
// `enum` doesn't actually make it into a subtype
// of the tag type, and thus doesn't violate the
// rules when the tag type is `sealed`.
}
else
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfEnumMustBeIntegerOrInterface, decl, baseType);
continue;
}
}
// If a tag type has not been set, then we
// default it to the built-in `int` type.
//
// TODO: In the far-flung future we may want to distinguish
// `enum` types that have a "raw representation" like this from
// ones that are purely abstract and don't expose their
// type of their tag.
//
if(!tagType)
{
tagType = m_astBuilder->getIntType();
}
else
{
// TODO: Need to establish that the tag
// type is suitable. (e.g., if we are going
// to allow raw values for case tags to be
// derived automatically, then the tag
// type needs to be some kind of integer type...)
//
// For now we will just be harsh and require it
// to be one of a few builtin types.
validateEnumTagType(tagType, tagTypeInheritanceDecl->loc);
// Note: The `InheritanceDecl` that introduces a tag
// type isn't actually representing a super-type of
// the `enum`, and things like name lookup need to
// know to ignore that "inheritance" relationship.
//
// We add a modifier to the `InheritanceDecl` to ensure
// that it can be detected and ignored by such steps.
//
addModifier(tagTypeInheritanceDecl, m_astBuilder->create<IgnoreForLookupModifier>());
}
decl->tagType = tagType;
// An `enum` type should automatically conform to the `__EnumType` interface.
// The compiler needs to insert this conformance behind the scenes, and this
// seems like the best place to do it.
{
// First, look up the type of the `__EnumType` interface.
Type* enumTypeType = getASTBuilder()->getEnumTypeType();
InheritanceDecl* enumConformanceDecl = m_astBuilder->create<InheritanceDecl>();
enumConformanceDecl->parentDecl = decl;
enumConformanceDecl->loc = decl->loc;
enumConformanceDecl->base.type = getASTBuilder()->getEnumTypeType();
decl->members.add(enumConformanceDecl);
// The `__EnumType` interface has one required member, the `__Tag` type.
// We need to satisfy this requirement automatically, rather than require
// the user to actually declare a member with this name (otherwise we wouldn't
// let them define a tag value with the name `__Tag`).
//
RefPtr<WitnessTable> witnessTable = new WitnessTable();
witnessTable->baseType = enumConformanceDecl->base.type;
witnessTable->witnessedType = enumTypeType;
enumConformanceDecl->witnessTable = witnessTable;
Name* tagAssociatedTypeName = getSession()->getNameObj("__Tag");
Decl* tagAssociatedTypeDecl = nullptr;
if(auto enumTypeTypeDeclRefType = dynamicCast<DeclRefType>(enumTypeType))
{
if(auto enumTypeTypeInterfaceDecl = as<InterfaceDecl>(enumTypeTypeDeclRefType->getDeclRef().getDecl()))
{
for(auto memberDecl : enumTypeTypeInterfaceDecl->members)
{
if(memberDecl->getName() == tagAssociatedTypeName)
{
tagAssociatedTypeDecl = memberDecl;
break;
}
}
}
}
if(!tagAssociatedTypeDecl)
{
SLANG_DIAGNOSE_UNEXPECTED(getSink(), decl, "failed to find built-in declaration '__Tag'");
}
// Okay, add the conformance witness for `__Tag` being satisfied by `tagType`
witnessTable->add(tagAssociatedTypeDecl, RequirementWitness(tagType));
// TODO: we actually also need to synthesize a witness for the conformance of `tagType`
// to the `__BuiltinIntegerType` interface, because that is a constraint on the
// associated type `__Tag`.
// TODO: eventually we should consider synthesizing other requirements for
// the min/max tag values, or the total number of tags, so that people don't
// have to declare these as additional cases.
enumConformanceDecl->setCheckState(DeclCheckState::DefinitionChecked);
}
}
void SemanticsDeclBodyVisitor::visitEnumDecl(EnumDecl* decl)
{
SLANG_OUTER_SCOPE_CONTEXT_DECL_RAII(this, decl);
auto enumType = DeclRefType::create(m_astBuilder, makeDeclRef(decl));
auto tagType = decl->tagType;
// Check the enum cases in order.
for(auto caseDecl : decl->getMembersOfType<EnumCaseDecl>())
{
// Each case defines a value of the enum's type.
//
// TODO: If we ever support enum cases with payloads,
// then they would probably have a type that is a
// `FunctionType` from the payload types to the
// enum type.
//
// TODO(tfoley): the case should grab its type when
// doing its own header checking, rather than rely on this...
caseDecl->type.type = enumType;
ensureDecl(caseDecl, DeclCheckState::DefinitionChecked);
}
// For any enum case that didn't provide an explicit
// tag value, derived an appropriate tag value.
IntegerLiteralValue defaultTag = 0;
for(auto caseDecl : decl->getMembersOfType<EnumCaseDecl>())
{
if(auto explicitTagValExpr = caseDecl->tagExpr)
{
// This tag has an initializer, so it should establish
// the tag value for a successor case that doesn't
// provide an explicit tag.
IntVal* explicitTagVal = tryConstantFoldExpr(explicitTagValExpr, nullptr);
if(explicitTagVal)
{
if(auto constIntVal = as<ConstantIntVal>(explicitTagVal))
{
defaultTag = constIntVal->getValue();
}
else
{
// TODO: need to handle other possibilities here
getSink()->diagnose(explicitTagValExpr, Diagnostics::unexpectedEnumTagExpr);
}
}
else
{
// If this happens, then the explicit tag value expression
// doesn't seem to be a constant after all. In this case
// we expect the checking logic to have applied already.
}
}
else
{
// This tag has no initializer, so it should use
// the default tag value we are tracking.
IntegerLiteralExpr* tagValExpr = m_astBuilder->create<IntegerLiteralExpr>();
tagValExpr->loc = caseDecl->loc;
tagValExpr->type = QualType(tagType);
tagValExpr->value = defaultTag;
caseDecl->tagExpr = tagValExpr;
}
// Default tag for the next case will be one more than
// for the most recent case.
//
// TODO: We might consider adding a `[flags]` attribute
// that modifies this behavior to be `defaultTagForCase <<= 1`.
//
defaultTag++;
}
}
void SemanticsDeclBodyVisitor::visitEnumCaseDecl(EnumCaseDecl* decl)
{
// An enum case had better appear inside an enum!
//
// TODO: Do we need/want to support generic cases some day?
auto parentEnumDecl = as<EnumDecl>(decl->parentDecl);
SLANG_ASSERT(parentEnumDecl);
decl->type.type = DeclRefType::create(m_astBuilder, makeDeclRef(parentEnumDecl));
// The tag type should have already been set by
// the surrounding `enum` declaration.
auto tagType = parentEnumDecl->tagType;
SLANG_ASSERT(tagType);
// Need to check the init expression, if present, since
// that represents the explicit tag for this case.
if(auto initExpr = decl->tagExpr)
{
initExpr = CheckTerm(initExpr);
initExpr = coerce(CoercionSite::General, tagType, initExpr);
// We want to enforce that this is an integer constant
// expression, but we don't actually care to retain
// the value.
CheckIntegerConstantExpression(initExpr, IntegerConstantExpressionCoercionType::AnyInteger, nullptr);
decl->tagExpr = initExpr;
}
}
void SemanticsVisitor::ensureDeclBase(DeclBase* declBase, DeclCheckState state, SemanticsContext* baseContext)
{
if(auto decl = as<Decl>(declBase))
{
ensureDecl(decl, state, baseContext);
}
else if(auto declGroup = as<DeclGroup>(declBase))
{
for(auto dd : declGroup->decls)
{
ensureDecl(dd, state, baseContext);
}
}
else
{
SLANG_UNEXPECTED("unknown case for declaration");
}
}
void SemanticsDeclHeaderVisitor::visitTypeDefDecl(TypeDefDecl* decl)
{
decl->type = CheckProperType(decl->type);
checkVisibility(decl);
}
void SemanticsDeclHeaderVisitor::visitGlobalGenericParamDecl(GlobalGenericParamDecl* decl)
{
// global generic param only allowed in global scope
auto program = as<ModuleDecl>(decl->parentDecl);
if (!program)
getSink()->diagnose(decl, Slang::Diagnostics::globalGenParamInGlobalScopeOnly);
}
void SemanticsDeclHeaderVisitor::visitAssocTypeDecl(AssocTypeDecl* decl)
{
// assoctype only allowed in an interface
auto interfaceDecl = as<InterfaceDecl>(decl->parentDecl);
if (!interfaceDecl)
getSink()->diagnose(decl, Slang::Diagnostics::assocTypeInInterfaceOnly);
checkVisibility(decl);
}
void SemanticsDeclBodyVisitor::visitFunctionDeclBase(FunctionDeclBase* decl)
{
auto newContext = withParentFunc(decl);
if (newContext.getParentDifferentiableAttribute())
{
// Register additional types outside the function body first.
auto oldAttr = m_parentDifferentiableAttr;
m_parentDifferentiableAttr = newContext.getParentDifferentiableAttribute();
for (auto param : decl->getParameters())
maybeRegisterDifferentiableType(m_astBuilder, param->type.type);
maybeRegisterDifferentiableType(m_astBuilder, decl->returnType.type);
if (as<ConstructorDecl>(decl) || !isEffectivelyStatic(decl))
{
auto parentDecl = getParentDecl(decl);
auto parentDeclRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(parentDecl));
auto thisType = calcThisType(parentDeclRef);
maybeRegisterDifferentiableType(m_astBuilder, thisType);
}
m_parentDifferentiableAttr = oldAttr;
}
if (const auto body = decl->body)
{
checkStmt(decl->body, newContext);
}
}
void SemanticsVisitor::getGenericParams(
GenericDecl* decl,
List<Decl*>& outParams,
List<GenericTypeConstraintDecl*>& outConstraints)
{
for (auto dd : decl->members)
{
if (dd == decl->inner)
continue;
if (auto typeParamDecl = as<GenericTypeParamDecl>(dd))
outParams.add(typeParamDecl);
else if (auto valueParamDecl = as<GenericValueParamDecl>(dd))
outParams.add(valueParamDecl);
else if (auto constraintDecl = as<GenericTypeConstraintDecl>(dd))
outConstraints.add(constraintDecl);
}
}
bool SemanticsVisitor::doGenericSignaturesMatch(
GenericDecl* left,
GenericDecl* right,
DeclRef<Decl>* outSpecializedRightInner)
{
// Our first goal here is to determine if `left` and
// `right` have equivalent lists of explicit
// generic parameters.
//
// Once we have determined that the explicit generic
// parameters match, we will look at the constraints
// placed on those parameters to see if they are
// equivalent.
//
// We thus start by extracting the explicit parameters
// and the constraints from each declaration.
//
List<Decl*> leftParams;
List<GenericTypeConstraintDecl*> leftConstraints;
getGenericParams(left, leftParams, leftConstraints);
List<Decl*> rightParams;
List<GenericTypeConstraintDecl*> rightConstraints;
getGenericParams(right, rightParams, rightConstraints);
// For there to be any hope of a match, the two decls
// need to have the same number of explicit parameters.
//
Index paramCount = leftParams.getCount();
if(paramCount != rightParams.getCount())
return false;
// Next we will walk through the parameters and look
// for a pair-wise match.
//
for(Index pp = 0; pp < paramCount; ++pp)
{
Decl* leftParam = leftParams[pp];
Decl* rightParam = rightParams[pp];
if (const auto leftTypeParam = as<GenericTypeParamDecl>(leftParam))
{
if (const auto rightTypeParam = as<GenericTypeParamDecl>(rightParam))
{
// Right now any two type parameters are a match.
// Names are irrelevant to matching, and any constraints
// on the type parameters are represented as implicit
// extra parameters of the generic.
//
// TODO: If we ever supported type parameters with
// higher kinds we might need to make a check here
// that the kind of each parameter matches (which
// would in a sense be a kind of recursive check
// of the generic signature of the parameter).
//
continue;
}
}
else if (auto leftValueParam = as<GenericValueParamDecl>(leftParam))
{
if (auto rightValueParam = as<GenericValueParamDecl>(rightParam))
{
// In this case we have two generic value parameters,
// and they should only be considered to match if
// they have the same type.
//
// Note: We are assuming here that the type of a value
// parameter cannot be dependent on any of the type
// parameters in the same signature. This is a reasonable
// assumption for now, but could get thorny down the road.
//
if (!leftValueParam->getType()->equals(rightValueParam->getType()))
{
// If the value parameters have non-matching types,
// then the full generic signatures do not match.
//
return false;
}
// Generic value parameters with the same type are
// always considered to match.
//
continue;
}
}
// If we get to this point, then we have two parameters that
// were of different syntatic categories (e.g., one type parameter
// and one value parameter), so the signatures clearly don't match.
//
return false;
}
// At this point we know that the explicit generic parameters
// of `left` and `right` are aligned, but we need to check
// that the constraints that each declaration places on
// its parameters match.
//
// A first challenge that arises is that `left` and `right`
// will each express the constraints in terms of their
// own parameters. For example, consider the following
// declarations:
//
// void foo1<T : IFoo>(T value);
// void foo2<U : IFoo>(U value);
//
// It is "obvious" to a human that the signatures here
// match, but `foo1` has a constraint `T : IFoo` while
// `foo2` has a constraint `U : IFoo`, and since `T`
// and `U` are distinct `Decl`s, those constraints
// are not obviously equivalent.
//
// We will work around this first issue by creating
// a substitution taht lists all the parameters of
// `left`, which we can use to specialize `right`
// so that it aligns.
//
// In terms of the example above, this is like constructing
// `foo2<T>` so that its constraint, after specialization,
// looks like `T : IFoo`.
//
auto& substInnerRightToLeft = *outSpecializedRightInner;
List<Val*> leftArgs = getDefaultSubstitutionArgs(m_astBuilder, this, left);
substInnerRightToLeft = m_astBuilder->getGenericAppDeclRef(makeDeclRef(right), leftArgs.getArrayView());
// We should now be able to enumerate the constraints
// on `right` in a way that uses the same type parameters
// as `left`, using `rightDeclRef`.
//
// At this point a second problem arises: if/when we support
// more flexibility in how generic parameter constraints are
// specified, it will be possible for two declarations to
// list the "same" constraints in very different ways.
//
// For example, if we support a `where` clause for separating
// the constraints from the parameters, then the following
// two declarations should have equivalent signatures:
//
// void foo1<T>(T value)
// where T : IFoo
// { ... }
//
// void foo2<T : IFoo>(T value)
// { ... }
//
// Similarly, if we allow for general compositions of interfaces
// to be used as constraints, then there can be more than one
// way to specify the same constraints:
//
// void foo1<T : IFoo&IBar>(T value);
// void foo2<T : IBar&IFoo>(T value);
//
// Adding support for equality constraints in `where` clauses
// also creates opportunities for multiple equivalent expressions:
//
// void foo1<T,U>(...) where T.A == U.A;
// void foo2<T,U>(...) where U.A == T.A;
//
// A robsut version of the checking logic here should attempt
// to *canonicalize* all of the constraints. Canonicalization
// should involve putting constraints into a deterministic
// order (e.g., for a generic with `<T,U>` all the constraints
// on `T` should come before those on `U`), rewriting individual
// constraints into a canonical form (e.g., `T : IFoo & IBar`
// should turn into two constraints: `T : IFoo` and `T : IBar`),
// etc.
//
// Once the constraints are in a canonical form we should be able
// to test them for pairwise equivalent. As a safety measure we
// could also try to test whether one set of constraints implies
// the other (since implication in both directions should imply
// equivalence, in which case our canonicalization had better
// have produced the same result).
//
// For now we are taking a simpler short-cut by assuming
// that constraints are already in a canonical form, which
// is reasonable for now as the syntax only allows a single
// constraint per parameter, specified on the parameter itself.
//
// Under the assumption of canonical constraints, we can
// assume that different numbers of constraints must indicate
// a signature mismatch.
//
Index constraintCount = leftConstraints.getCount();
if(constraintCount != rightConstraints.getCount())
return false;
for (Index cc = 0; cc < constraintCount; ++cc)
{
// Note that we use a plain `Decl` pointer for the left
// constraint, but need to use a `DeclRef` for the right
// constraint so that we can take the substitution
// arguments into account.
//
GenericTypeConstraintDecl* leftConstraint = leftConstraints[cc];
auto unspecializedRightConstarintDeclRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(rightConstraints[cc]));
DeclRef<GenericTypeConstraintDecl> rightConstraint = substInnerRightToLeft.substitute(
m_astBuilder, unspecializedRightConstarintDeclRef).as<GenericTypeConstraintDecl>();
// For now, every constraint has the form `sub : sup`
// to indicate that `sub` must be a subtype of `sup`.
//
// Two such constraints are equivalent if their `sub`
// and `sup` types are pairwise equivalent.
//
auto leftSub = leftConstraint->sub;
auto rightSub = getSub(m_astBuilder, rightConstraint);
if(!leftSub->equals(rightSub))
return false;
auto leftSup = leftConstraint->sup;
auto rightSup = getSup(m_astBuilder, rightConstraint);
if(!leftSup->equals(rightSup))
return false;
}
// If we have checked all of the (canonicalized) constraints
// and found them to be pairwise equivalent then the two
// generic signatures seem to match.
//
return true;
}
bool SemanticsVisitor::doFunctionSignaturesMatch(
DeclRef<FuncDecl> fst,
DeclRef<FuncDecl> snd)
{
// TODO(tfoley): This copies the parameter array, which is bad for performance.
auto fstParams = getParameters(m_astBuilder, fst).toArray();
auto sndParams = getParameters(m_astBuilder, snd).toArray();
// If the functions have different numbers of parameters, then
// their signatures trivially don't match.
auto fstParamCount = fstParams.getCount();
auto sndParamCount = sndParams.getCount();
if (fstParamCount != sndParamCount)
return false;
for (Index ii = 0; ii < fstParamCount; ++ii)
{
auto fstParam = fstParams[ii];
auto sndParam = sndParams[ii];
// If a given parameter type doesn't match, then signatures don't match
if (!getType(m_astBuilder, fstParam)->equals(getType(m_astBuilder, sndParam)))
return false;
// If one parameter is `out` and the other isn't, then they don't match
//
// Note(tfoley): we don't consider `out` and `inout` as distinct here,
// because there is no way for overload resolution to pick between them.
if (fstParam.getDecl()->hasModifier<OutModifier>() != sndParam.getDecl()->hasModifier<OutModifier>())
return false;
// If one parameter is `ref` and the other isn't, then they don't match.
//
if(fstParam.getDecl()->hasModifier<RefModifier>() != sndParam.getDecl()->hasModifier<RefModifier>())
return false;
// If one parameter is `constref` and the other isn't, then they don't match.
//
if (fstParam.getDecl()->hasModifier<ConstRefModifier>() != sndParam.getDecl()->hasModifier<ConstRefModifier>())
return false;
}
// Note(tfoley): return type doesn't enter into it, because we can't take
// calling context into account during overload resolution.
return true;
}
List<Val*> getDefaultSubstitutionArgs(ASTBuilder* astBuilder, SemanticsVisitor* semantics, GenericDecl* genericDecl)
{
List<Val*> args;
if (astBuilder->m_cachedGenericDefaultArgs.tryGetValue(genericDecl, args))
return args;
for (auto mm : genericDecl->members)
{
if (auto genericTypeParamDecl = as<GenericTypeParamDecl>(mm))
{
args.add(DeclRefType::create(astBuilder, astBuilder->getDirectDeclRef(genericTypeParamDecl)));
}
else if (auto genericValueParamDecl = as<GenericValueParamDecl>(mm))
{
if (semantics)
semantics->ensureDecl(genericValueParamDecl, DeclCheckState::ReadyForLookup);
args.add(astBuilder->getOrCreate<GenericParamIntVal>(
genericValueParamDecl->getType(),
astBuilder->getDirectDeclRef(genericValueParamDecl)));
}
}
bool shouldCache = true;
// create default substitution arguments for constraints
for (auto mm : genericDecl->members)
{
if (auto genericTypeConstraintDecl = as<GenericTypeConstraintDecl>(mm))
{
if (semantics)
semantics->ensureDecl(genericTypeConstraintDecl, DeclCheckState::ReadyForReference);
auto constraintDeclRef = astBuilder->getDirectDeclRef<GenericTypeConstraintDecl>(genericTypeConstraintDecl);
auto witness =
astBuilder->getDeclaredSubtypeWitness(
getSub(astBuilder, constraintDeclRef),
getSup(astBuilder, constraintDeclRef),
constraintDeclRef);
// TODO: this is an ugly hack to prevent crashing.
// In early stages of compilation witness->sub and witness->sup may not be checked yet.
// When semanticVisitor is present we have used that to ensure the type is checked.
// However due to how the code is written we cannot guarantee semanticVisitor is always available
// here, and if we can't get the checked sup/sub type this subst is incomplete and should not be
// cached.
if (!witness->getSub())
shouldCache = false;
args.add(witness);
}
}
if (shouldCache)
astBuilder->m_cachedGenericDefaultArgs[genericDecl] = args;
return args;
}
typedef Dictionary<Name*, CallableDecl*> TargetDeclDictionary;
static void _addTargetModifiers(CallableDecl* decl, TargetDeclDictionary& ioDict)
{
if (auto specializedModifier = decl->findModifier<SpecializedForTargetModifier>())
{
// If it's specialized for target it should have a body...
if (auto funcDecl = as<FunctionDeclBase>(decl))
{
// Normally if we have specialization for target it must have a body.
if (funcDecl->body == nullptr)
{
// If it doesn't have a body but does have a target intrinsic/SPIRVInstructionOp
// it's probably ok
SLANG_ASSERT(funcDecl->findModifier<SPIRVInstructionOpAttribute>() ||
funcDecl->findModifier<TargetIntrinsicModifier>());
}
}
Name* targetName = specializedModifier->targetToken.getName();
ioDict.addIfNotExists(targetName, decl);
}
else
{
for (auto modifier : decl->getModifiersOfType<TargetIntrinsicModifier>())
{
Name* targetName = modifier->targetToken.getName();
ioDict.addIfNotExists(targetName, decl);
}
auto funcDecl = as<FunctionDeclBase>(decl);
if (funcDecl && funcDecl->body)
{
// Should only be one body if it isn't specialized for target.
// Use nullptr for this scenario
ioDict.addIfNotExists(nullptr, decl);
}
}
}
Result SemanticsVisitor::checkFuncRedeclaration(
FuncDecl* newDecl,
FuncDecl* oldDecl)
{
// There are a few different cases that this function needs
// to check for:
//
// * If `newDecl` and `oldDecl` have different signatures such
// that they can always be distinguished at call sites, then
// they don't conflict and don't count as redeclarations.
//
// * If `newDecl` and `oldDecl` have matching signatures, but
// differ in return type (or other details that would affect
// compatibility), then the declarations conflict and an
// error needs to be diagnosed.
//
// * If `newDecl` and `oldDecl` have matching/compatible sigantures,
// but differ when it comes to target-specific overloading,
// then they can co-exist.
//
// * If `newDecl` and `oldDecl` have matching/compatible signatures
// and are specialized for the same target(s), then only
// one can have a body (in which case the other is a forward declaration),
// or else we have a redefinition error.
auto newGenericDecl = as<GenericDecl>(newDecl->parentDecl);
auto oldGenericDecl = as<GenericDecl>(oldDecl->parentDecl);
// If one declaration is a prefix/postfix operator, and the
// other is not a matching operator, then don't consider these
// to be re-declarations.
//
// Note(tfoley): Any attempt to call such an operator using
// ordinary function-call syntax (if we decided to allow it)
// would be ambiguous in such a case, of course.
//
if (newDecl->hasModifier<PrefixModifier>() != oldDecl->hasModifier<PrefixModifier>())
return SLANG_OK;
if (newDecl->hasModifier<PostfixModifier>() != oldDecl->hasModifier<PostfixModifier>())
return SLANG_OK;
// If one is generic and the other isn't, then there is no match.
if ((newGenericDecl != nullptr) != (oldGenericDecl != nullptr))
return SLANG_OK;
// We are going to be comparing the signatures of the
// two functions, but if they are *generic* functions
// then we will need to compare them with consistent
// specializations in place.
//
// We'll go ahead and create some (unspecialized) declaration
// references here, just to be prepared.
//
DeclRef<FuncDecl> newDeclRef(newDecl);
DeclRef<FuncDecl> oldDeclRef(oldDecl);
// If we are working with generic functions, then we need to
// consider if their generic signatures match.
//
if(newGenericDecl)
{
// If one declaration is generic, the other must be.
// (This condition was already checked above)
//
SLANG_ASSERT(oldGenericDecl);
// As part of checking if the generic signatures match,
// we will produce a substitution that can be used to
// reference `oldGenericDecl` with the generic parameters
// substituted for those of `newDecl`.
//
// One way to think about it is that if we have these
// declarations (ignore the name differences...):
//
// // oldDecl:
// void foo1<T>(T x);
//
// // newDecl:
// void foo2<U>(U x);
//
// Then we will compare the parameter types of `foo2`
// against the specialization `foo1<U>`.
//
DeclRef<Decl> specializedOldDeclInner;
if(!doGenericSignaturesMatch(newGenericDecl, oldGenericDecl, &specializedOldDeclInner))
return SLANG_OK;
oldDeclRef = specializedOldDeclInner.as<FuncDecl>();
}
// If the parameter signatures don't match, then don't worry
if (!doFunctionSignaturesMatch(newDeclRef, oldDeclRef))
return SLANG_OK;
// If we get this far, then we've got two declarations in the same
// scope, with the same name and signature, so they appear
// to be redeclarations.
//
// We will track that redeclaration occured, so that we can
// take it into account for overload resolution.
//
// A huge complication that we'll need to deal with is that
// multiple declarations might introduce default values for
// (different) parameters, and we might need to merge across
// all of them (which could get complicated if defaults for
// parameters can reference earlier parameters).
// If the previous declaration wasn't already recorded
// as being part of a redeclaration family, then make
// it the primary declaration of a new family.
if (!oldDecl->primaryDecl)
{
oldDecl->primaryDecl = oldDecl;
}
// The new declaration will belong to the family of
// the previous one, and so it will share the same
// primary declaration.
newDecl->primaryDecl = oldDecl->primaryDecl;
newDecl->nextDecl = nullptr;
// Next we want to chain the new declaration onto
// the linked list of redeclarations.
auto link = &oldDecl->nextDecl;
while (*link)
link = &(*link)->nextDecl;
*link = newDecl;
// Now that we've added things to a group of redeclarations,
// we can do some additional validation.
// First, we will ensure that the return types match
// between the declarations, so that they are truly
// interchangeable.
//
// Note(tfoley): If we ever decide to add a beefier type
// system to Slang, we might allow overloads like this,
// so long as the desired result type can be disambiguated
// based on context at the call type. In that case we would
// consider result types earlier, as part of the signature
// matching step.
//
auto resultType = getResultType(m_astBuilder, newDeclRef);
auto prevResultType = getResultType(m_astBuilder, oldDeclRef);
if (!resultType->equals(prevResultType))
{
// Bad redeclaration
getSink()->diagnose(newDecl, Diagnostics::functionRedeclarationWithDifferentReturnType, newDecl->getName(), resultType, prevResultType);
getSink()->diagnose(oldDecl, Diagnostics::seePreviousDeclarationOf, newDecl->getName());
// Don't bother emitting other errors at this point
return SLANG_FAIL;
}
// TODO: Enforce that the new declaration had better
// not specify a default value for any parameter that
// already had a default value in a prior declaration.
// We are going to want to enforce that we cannot have
// two declarations of a function both specify bodies.
// Before we make that check, however, we need to deal
// with the case where the two function declarations
// might represent different target-specific versions
// of a function.
// If both of the declarations have a body, then there
// is trouble, because we wouldn't know which one to
// use during code generation.
// Here to cover the 'bodies'/target_intrinsics, we find all the targets that
// that are previously defined, and make sure the new definition
// doesn't try and define what is already defined.
{
TargetDeclDictionary currentTargets;
{
CallableDecl* curDecl = newDecl->primaryDecl;
while (curDecl)
{
if (curDecl != newDecl)
{
_addTargetModifiers(curDecl, currentTargets);
}
curDecl = curDecl->nextDecl;
}
}
// Add the targets for this new decl
TargetDeclDictionary newTargets;
_addTargetModifiers(newDecl, newTargets);
bool hasConflict = false;
for (auto& [target, value] : newTargets)
{
auto found = currentTargets.tryGetValue(target);
if (found)
{
// Redefinition
if (!hasConflict)
{
getSink()->diagnose(newDecl, Diagnostics::functionRedefinition, newDecl->getName());
hasConflict = true;
}
auto prevDecl = *found;
getSink()->diagnose(prevDecl, Diagnostics::seePreviousDefinitionOf, prevDecl->getName());
}
}
if (hasConflict)
{
return SLANG_FAIL;
}
}
// At this point we've processed the redeclaration and
// put it into a group, so there is no reason to keep
// looping and looking at prior declarations.
//
// While no diagnostics have been emitted, we return
// a failure result from the operation to indicate
// to the caller that they should stop looping over
// declarations at this point.
//
return SLANG_FAIL;
}
Result SemanticsVisitor::checkRedeclaration(Decl* newDecl, Decl* oldDecl)
{
// If either of the declarations being looked at is generic, then
// we want to consider the "inner" declaration instead when
// making decisions about what to allow or not.
//
if(auto newGenericDecl = as<GenericDecl>(newDecl))
newDecl = newGenericDecl->inner;
if(auto oldGenericDecl = as<GenericDecl>(oldDecl))
oldDecl = oldGenericDecl->inner;
// Functions are special in that we can have many declarations
// with the same name in a given scope, and it is possible
// for them to co-exist as overloads, or even just be multiple
// declarations of the same function (thanks to the inherited
// legacy of C forward declarations).
//
// If both declarations are functions, we will check that
// they are allowed to co-exist using these more nuanced rules.
//
if( auto newFuncDecl = as<FuncDecl>(newDecl) )
{
if(auto oldFuncDecl = as<FuncDecl>(oldDecl) )
{
// Both new and old declarations are functions,
// so redeclaration may be valid.
return checkFuncRedeclaration(newFuncDecl, oldFuncDecl);
}
}
if (as<ModuleDeclarationDecl>(oldDecl) || as<ModuleDeclarationDecl>(newDecl))
{
// It is allowed to have a decl whose name is the same as the module.
return SLANG_OK;
}
// For all other flavors of declaration, we do not
// allow duplicate declarations with the same name.
//
// TODO: We might consider allowing some other cases
// of overloading that can be safely disambiguated:
//
// * A type and a value (function/variable/etc.) of the same name can usually
// co-exist because we can distinguish which is needed by context.
//
// * Multiple generic types with the same name can co-exist
// if their generic parameter lists are sufficient to
// tell them apart at a use site.
// We will diagnose a redeclaration error at the new declaration,
// and point to the old declaration for context.
//
getSink()->diagnose(newDecl, Diagnostics::redeclaration, newDecl->getName());
getSink()->diagnose(oldDecl, Diagnostics::seePreviousDeclarationOf, oldDecl->getName());
return SLANG_FAIL;
}
void SemanticsVisitor::checkForRedeclaration(Decl* decl)
{
// We want to consider a "new" declaration in the context
// of some parent/container declaration, and compare it
// to pre-existing "old" declarations of the same name
// in the same container.
//
auto newDecl = decl;
auto parentDecl = decl->parentDecl;
// Sanity check: there should always be a parent declaration.
//
SLANG_ASSERT(parentDecl);
if (!parentDecl) return;
// If the declaration is the "inner" declaration of a generic,
// then we actually want to look one level up, because the
// peers/siblings of the declaration will belong to the same
// parent as the generic, not to the generic.
//
if( auto genericParentDecl = as<GenericDecl>(parentDecl) )
{
// Note: we need to check here to be sure `newDecl`
// is the "inner" declaration and not one of the
// generic parameters, or else we will end up
// checking them at the wrong scope.
//
if( newDecl == genericParentDecl->inner )
{
newDecl = parentDecl;
parentDecl = genericParentDecl->parentDecl;
}
}
// We will now look for other declarations with
// the same name in the same parent/container.
//
parentDecl->buildMemberDictionary();
for (auto oldDecl = newDecl->nextInContainerWithSameName; oldDecl; oldDecl = oldDecl->nextInContainerWithSameName)
{
// For each matching declaration, we will check
// whether the redeclaration should be allowed,
// and emit an appropriate diagnostic if not.
//
Result checkResult = checkRedeclaration(newDecl, oldDecl);
// The `checkRedeclaration` function will return a failure
// status (whether or not it actually emitted a diagnostic)
// if we should stop checking further redeclarations, because
// the declaration in question has been dealt with fully.
//
if(SLANG_FAILED(checkResult))
break;
}
}
void SemanticsDeclHeaderVisitor::visitParamDecl(ParamDecl* paramDecl)
{
// TODO: This logic should be shared with the other cases of
// variable declarations. The main reason I am not doing it
// yet is that we use a `ParamDecl` with a null type as a
// special case in attribute declarations, and that could
// trip up the ordinary variable checks.
auto typeExpr = paramDecl->type;
if(typeExpr.exp)
{
typeExpr = CheckUsableType(typeExpr);
paramDecl->type = typeExpr;
checkMeshOutputDecl(paramDecl);
}
if (auto declRefType = as<DeclRefType>(paramDecl->type.type))
{
if (declRefType->getDeclRef().getDecl()->findModifier<NonCopyableTypeAttribute>())
{
// Always pass a non-copyable type by reference.
// Remove all existing direction modifiers, and replace them with a single Ref modifier.
List<Modifier*> newModifiers;
bool hasRefModifier = false;
bool isMutable = false;
for (auto modifier : paramDecl->modifiers)
{
if (as<InModifier>(modifier))
{
continue;
}
else if (as<InOutModifier>(modifier) || as<OutModifier>(modifier))
{
isMutable = true;
continue;
}
if (as<RefModifier>(modifier) || as<ConstRefModifier>(modifier))
{
hasRefModifier = true;
}
newModifiers.add(modifier);
}
if (!hasRefModifier)
{
if (isMutable)
newModifiers.add(this->getASTBuilder()->create<RefModifier>());
else
newModifiers.add(this->getASTBuilder()->create<ConstRefModifier>());
}
paramDecl->modifiers.first = newModifiers.getFirst();
for (Index i = 0; i < newModifiers.getCount(); i++)
{
if (i < newModifiers.getCount() - 1)
newModifiers[i]->next = newModifiers[i + 1];
else
newModifiers[i]->next = nullptr;
}
}
}
}
// This checks that the declaration is marked as "out" and changes the hlsl
// modifier based syntax into a proper type.
void SemanticsDeclHeaderVisitor::checkMeshOutputDecl(VarDeclBase* varDecl)
{
auto modifier = varDecl->findModifier<HLSLMeshShaderOutputModifier>();
auto meshOutputType = as<MeshOutputType>(varDecl->type.type);
bool isMeshOutput = modifier || meshOutputType;
if(!isMeshOutput)
{
return;
}
if(!varDecl->findModifier<OutModifier>())
{
getSink()->diagnose(varDecl, Diagnostics::meshOutputMustBeOut);
}
//
// If necessary, convert to our typed representation
//
if(!modifier)
{
return;
}
if(meshOutputType)
{
getSink()->diagnose(modifier, Diagnostics::unnecessaryHLSLMeshOutputModifier);
varDecl->type.type = m_astBuilder->getErrorType();
return;
}
auto indexExpr = as<IndexExpr>(varDecl->type.exp);
if(!indexExpr)
{
getSink()->diagnose(varDecl, Diagnostics::meshOutputMustBeArray);
varDecl->type.type = m_astBuilder->getErrorType();
return;
}
if(indexExpr->indexExprs.getCount() != 1)
{
getSink()->diagnose(varDecl, Diagnostics::meshOutputArrayMustHaveSize);
varDecl->type.type = m_astBuilder->getErrorType();
return;
}
auto base = ExpectAType(indexExpr->baseExpression);
auto index = CheckIntegerConstantExpression(
indexExpr->indexExprs[0],
IntegerConstantExpressionCoercionType::AnyInteger,
nullptr,
getSink());
Type* d = m_astBuilder->getMeshOutputTypeFromModifier(modifier, base, index);
varDecl->type.type = d;
}
void SemanticsDeclBodyVisitor::visitParamDecl(ParamDecl* paramDecl)
{
auto typeExpr = paramDecl->type;
// The "initializer" expression for a parameter represents
// a default argument value to use if an explicit one is
// not supplied.
if(auto initExpr = paramDecl->initExpr)
{
// We must check the expression and coerce it to the
// actual type of the parameter.
//
initExpr = CheckTerm(initExpr);
initExpr = coerce(CoercionSite::Initializer, typeExpr.type, initExpr);
paramDecl->initExpr = initExpr;
// TODO: a default argument expression needs to
// conform to other constraints to be valid.
// For example, it should not be allowed to refer
// to other parameters of the same function (or maybe
// only the parameters to its left...).
// A default argument value should not be allowed on an
// `out` or `inout` parameter.
//
// TODO: we could relax this by requiring the expression
// to yield an lvalue, but that seems like a feature
// with limited practical utility (and an easy source
// of confusing behavior).
//
// Note: the `InOutModifier` class inherits from `OutModifier`,
// so we only need to check for the base case.
//
if(paramDecl->findModifier<OutModifier>())
{
getSink()->diagnose(initExpr, Diagnostics::outputParameterCannotHaveDefaultValue);
}
}
}
void SemanticsDeclBodyVisitor::visitAggTypeDecl(AggTypeDecl* aggTypeDecl)
{
if (aggTypeDecl->hasTag(TypeTag::Incomplete) && aggTypeDecl->hasModifier<HLSLExportModifier>())
{
getSink()->diagnose(aggTypeDecl->loc, Diagnostics::cannotExportIncompleteType, aggTypeDecl);
}
}
void SemanticsDeclHeaderVisitor::cloneModifiers(Decl* dest, Decl* src)
{
dest->modifiers = src->modifiers;
}
void SemanticsDeclHeaderVisitor::setFuncTypeIntoRequirementDecl(CallableDecl* decl, FuncType* funcType)
{
if (!funcType)
return;
decl->returnType.type = funcType->getResultType();
decl->errorType.type = funcType->getErrorType();
for (Index i = 0; i < funcType->getParamCount(); i++)
{
auto paramType = funcType->getParamType(i);
if (auto dirType = as<ParamDirectionType>(paramType))
paramType = dirType->getValueType();
auto param = m_astBuilder->create<ParamDecl>();
param->type.type = paramType;
auto paramDir = funcType->getParamDirection(i);
switch (paramDir)
{
case ParameterDirection::kParameterDirection_InOut:
addModifier(param, m_astBuilder->create<InOutModifier>());
break;
case ParameterDirection::kParameterDirection_Out:
addModifier(param, m_astBuilder->create<OutModifier>());
break;
case ParameterDirection::kParameterDirection_Ref:
addModifier(param, m_astBuilder->create<RefModifier>());
break;
case ParameterDirection::kParameterDirection_ConstRef:
addModifier(param, m_astBuilder->create<ConstRefModifier>());
break;
default:
break;
}
decl->members.add(param);
param->parentDecl = decl;
}
}
void SemanticsDeclHeaderVisitor::checkCallableDeclCommon(CallableDecl* decl)
{
for(auto paramDecl : decl->getParameters())
{
ensureDecl(paramDecl, DeclCheckState::ReadyForReference);
}
auto errorType = decl->errorType;
if (errorType.exp)
{
errorType = CheckProperType(errorType);
}
else
{
errorType = TypeExp(m_astBuilder->getBottomType());
}
decl->errorType = errorType;
if (auto interfaceDecl = findParentInterfaceDecl(decl))
{
bool isDiffFunc = false;
if (decl->hasModifier<ForwardDifferentiableAttribute>() || decl->hasModifier<BackwardDifferentiableAttribute>())
{
auto reqDecl = m_astBuilder->create<ForwardDerivativeRequirementDecl>();
reqDecl->originalRequirementDecl = decl;
cloneModifiers(reqDecl, decl);
auto declRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(decl)).as<CallableDecl>();
auto diffFuncType = getForwardDiffFuncType(getFuncType(m_astBuilder, declRef));
setFuncTypeIntoRequirementDecl(reqDecl, as<FuncType>(diffFuncType));
interfaceDecl->members.add(reqDecl);
reqDecl->parentDecl = interfaceDecl;
if (!decl->hasModifier<NoDiffThisAttribute>())
{
// Build decl-ref-type from interface.
auto interfaceType = DeclRefType::create(getASTBuilder(), makeDeclRef(interfaceDecl));
// If the interface is differentiable, make the this type a pair.
if (tryGetDifferentialType(getASTBuilder(), interfaceType))
reqDecl->diffThisType = getDifferentialPairType(interfaceType);
}
auto reqRef = m_astBuilder->create<DerivativeRequirementReferenceDecl>();
reqRef->referencedDecl = reqDecl;
reqRef->parentDecl = decl;
decl->members.add(reqRef);
isDiffFunc = true;
}
if (decl->hasModifier<BackwardDifferentiableAttribute>())
{
// Requirement for backward derivative.
auto declRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(decl)).as<CallableDecl>();
auto originalFuncType = getFuncType(m_astBuilder, declRef);
auto diffFuncType = as<FuncType>(getBackwardDiffFuncType(originalFuncType));
{
auto reqDecl = m_astBuilder->create<BackwardDerivativeRequirementDecl>();
reqDecl->originalRequirementDecl = decl;
cloneModifiers(reqDecl, decl);
setFuncTypeIntoRequirementDecl(reqDecl, diffFuncType);
interfaceDecl->members.add(reqDecl);
reqDecl->parentDecl = interfaceDecl;
if (!decl->hasModifier<NoDiffThisAttribute>())
{
// Build decl-ref-type from interface.
auto interfaceType = DeclRefType::create(getASTBuilder(), makeDeclRef(interfaceDecl));
// If the interface is differentiable, make the this type a pair.
if (tryGetDifferentialType(getASTBuilder(), interfaceType))
reqDecl->diffThisType = getDifferentialPairType(interfaceType);
}
auto reqRef = m_astBuilder->create<DerivativeRequirementReferenceDecl>();
reqRef->referencedDecl = reqDecl;
reqRef->parentDecl = decl;
decl->members.add(reqRef);
}
isDiffFunc = true;
}
if (isDiffFunc)
{
auto interfaceDeclRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, this, makeDeclRef(interfaceDecl));
auto interfaceType = DeclRefType::create(m_astBuilder, interfaceDeclRef);
bool noDiffThisRequirement = !isTypeDifferentiable(interfaceType);
if (noDiffThisRequirement)
{
auto noDiffThisModifier = m_astBuilder->create<NoDiffThisAttribute>();
addModifier(decl, noDiffThisModifier);
}
}
}
if (decl->findModifier<DifferentiableAttribute>())
{
// Add `no_diff` modifiers to parameters.
// This is necessary to preserve no-diff-ness for generic function before and after
// specialization.
for (auto paramDecl : decl->getParameters())
{
if (!paramDecl->type.type)
continue;
if (!isTypeDifferentiable(paramDecl->type.type))
{
if (!paramDecl->hasModifier<NoDiffModifier>())
{
auto noDiffModifier = m_astBuilder->create<NoDiffModifier>();
noDiffModifier->keywordName = getSession()->getNameObj("no_diff");
addModifier(paramDecl, noDiffModifier);
}
}
if (!paramDecl->hasModifier<NoDiffModifier>())
{
if (auto modifier = paramDecl->findModifier<ConstRefModifier>())
{
getSink()->diagnose(modifier, Diagnostics::cannotUseConstRefOnDifferentiableParameter);
}
}
}
if (!isEffectivelyStatic(decl))
{
auto constrefAttr = decl->findModifier<ConstRefAttribute>();
if (constrefAttr)
{
if (isTypeDifferentiable(calcThisType(getParentDecl(decl))))
{
getSink()->diagnose(constrefAttr, Diagnostics::cannotUseConstRefOnDifferentiableMemberMethod);
}
}
}
}
checkVisibility(decl);
}
void SemanticsDeclHeaderVisitor::visitFuncDecl(FuncDecl* funcDecl)
{
auto resultType = funcDecl->returnType;
if(resultType.exp)
{
resultType = CheckProperType(resultType);
}
else if (!funcDecl->returnType.type)
{
resultType = TypeExp(m_astBuilder->getVoidType());
}
funcDecl->returnType = resultType;
checkCallableDeclCommon(funcDecl);
}
IntegerLiteralValue SemanticsVisitor::GetMinBound(IntVal* val)
{
if (auto constantVal = as<ConstantIntVal>(val))
return constantVal->getValue();
// TODO(tfoley): Need to track intervals so that this isn't just a lie...
return 1;
}
void SemanticsVisitor::maybeInferArraySizeForVariable(VarDeclBase* varDecl)
{
// Not an array?
auto arrayType = as<ArrayExpressionType>(varDecl->type);
if (!arrayType) return;
// Explicit element count given?
if (!isUnsizedArrayType(arrayType))
return;
// No initializer?
auto initExpr = varDecl->initExpr;
if(!initExpr) return;
IntVal* elementCount = nullptr;
// Is the type of the initializer an array type?
if(auto arrayInitType = as<ArrayExpressionType>(initExpr->type))
{
elementCount = arrayInitType->getElementCount();
}
else
{
// Nothing to do: we couldn't infer a size
return;
}
// Create a new array type based on the size we found,
// and install it into our type.
varDecl->type.type = getArrayType(
m_astBuilder,
arrayType->getElementType(),
elementCount);
}
void SemanticsVisitor::validateArraySizeForVariable(VarDeclBase* varDecl)
{
auto arrayType = as<ArrayExpressionType>(varDecl->type);
if (!arrayType) return;
if (arrayType->isUnsized())
{
// Note(tfoley): For now we allow arrays of unspecified size
// everywhere, because some source languages (e.g., GLSL)
// allow them in specific cases.
#if 0
getSink()->diagnose(varDecl, Diagnostics::invalidArraySize);
#endif
return;
}
// TODO(tfoley): How to handle the case where bound isn't known?
auto elementCount = arrayType->getElementCount();
if (GetMinBound(elementCount) <= 0)
{
getSink()->diagnose(varDecl, Diagnostics::invalidArraySize);
return;
}
}
void SemanticsDeclBasesVisitor::_validateExtensionDeclTargetType(ExtensionDecl* decl)
{
if (auto targetDeclRefType = as<DeclRefType>(decl->targetType))
{
// Attach our extension to that type as a candidate...
if (auto aggTypeDeclRef = targetDeclRefType->getDeclRef().as<AggTypeDecl>())
{
auto aggTypeDecl = aggTypeDeclRef.getDecl();
getShared()->registerCandidateExtension(aggTypeDecl, decl);
return;
}
}
if (!as<ErrorType>(decl->targetType.type))
{
getSink()->diagnose(decl->targetType.exp, Diagnostics::invalidExtensionOnType, decl->targetType);
}
}
void SemanticsDeclBasesVisitor::visitExtensionDecl(ExtensionDecl* decl)
{
// We check the target type expression, and then validate
// that the type it names is one that it makes sense
// to extend.
//
decl->targetType = CheckProperType(decl->targetType);
_validateExtensionDeclTargetType(decl);
for( auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>() )
{
ensureDecl(inheritanceDecl, DeclCheckState::CanUseBaseOfInheritanceDecl);
auto baseType = inheritanceDecl->base.type;
// It is possible that there was an error in checking the base type
// expression, and in such a case we shouldn't emit a cascading error.
//
if( const auto baseErrorType = as<ErrorType>(baseType) )
{
continue;
}
// An `extension` can only introduce inheritance from `interface` types.
//
// TODO: It might in theory make sense to allow an `extension` to
// introduce a non-`interface` base if we decide that an `extension`
// within the same module as the type it extends counts as just
// a continuation of the type's body (like a `partial class` in C#).
//
auto baseDeclRefType = as<DeclRefType>(baseType);
if( !baseDeclRefType )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfExtensionMustBeInterface, decl, baseType);
continue;
}
auto baseDeclRef = baseDeclRefType->getDeclRef();
auto baseInterfaceDeclRef = baseDeclRef.as<InterfaceDecl>();
if( !baseInterfaceDeclRef )
{
getSink()->diagnose(inheritanceDecl, Diagnostics::baseOfExtensionMustBeInterface, decl, baseType);
continue;
}
// TODO: At this point we have the `baseInterfaceDeclRef`
// and could use it to perform further validity checks,
// and/or to build up a more refined representation of
// the inheritance graph for this extension (e.g., a "class
// precedence list").
//
// E.g., we can/should check that we aren't introducing
// an inheritance relationship that already existed
// on the type as originally declared.
_validateCrossModuleInheritance(decl, inheritanceDecl);
}
}
Type* SemanticsVisitor::calcThisType(DeclRef<Decl> declRef)
{
if( auto interfaceDeclRef = declRef.as<InterfaceDecl>() )
{
// In the body of an `interface`, a `This` type
// refers to the concrete type that will eventually
// conform to the interface and fill in its
// requirements.
//
return DeclRefType::create(
m_astBuilder,
m_astBuilder->getDirectDeclRef(interfaceDeclRef.getDecl()->getThisTypeDecl()));
}
else if (auto aggTypeDeclRef = declRef.as<AggTypeDecl>())
{
// In the body of an ordinary aggregate type,
// such as a `struct`, the `This` type just
// refers to the type itself.
//
// TODO: If/when we support `class` types
// with inheritance, then `This` inside a class
// would need to refer to the eventual concrete
// type, much like the `interface` case above.
//
return DeclRefType::create(m_astBuilder, aggTypeDeclRef);
}
else if (auto extDeclRef = declRef.as<ExtensionDecl>())
{
// In the body of an `extension`, the `This`
// type refers to the type being extended.
//
// Note: we currently have this loop back
// around through `calcThisType` for the
// type being extended, rather than just
// using it directly. This makes a difference
// for polymorphic types like `interface`s,
// and there are reasonable arguments for
// the validity of either option.
//
// Does `extension IFoo` mean extending
// exactly the type `IFoo` (an existential,
// which could at runtime be a value of
// any type conforming to `IFoo`), or does
// it implicitly extend every type that
// conforms to `IFoo`? The difference is
// significant, and we need to make a choice
// sooner or later.
//
ensureDecl(extDeclRef, DeclCheckState::CanUseExtensionTargetType);
auto targetType = getTargetType(m_astBuilder, extDeclRef);
return calcThisType(targetType);
}
else
{
return nullptr;
}
}
Type* SemanticsVisitor::calcThisType(Type* type)
{
if( auto declRefType = as<DeclRefType>(type) )
{
return calcThisType(declRefType->getDeclRef());
}
else
{
return type;
}
}
Type* SemanticsVisitor::findResultTypeForConstructorDecl(ConstructorDecl* decl)
{
// We want to look at the parent of the declaration,
// but if the declaration is generic, the parent will be
// the `GenericDecl` and we need to skip past that to
// the grandparent.
//
auto parent = decl->parentDecl;
auto genericParent = as<GenericDecl>(parent);
if (genericParent)
{
parent = genericParent->parentDecl;
}
// The result type for a constructor is whatever `This` would
// refer to in the body of the outer declaration.
//
auto thisType = calcThisType(makeDeclRef(parent));
if( !thisType )
{
getSink()->diagnose(decl, Diagnostics::initializerNotInsideType);
thisType = m_astBuilder->getErrorType();
}
return thisType;
}
void SemanticsDeclHeaderVisitor::visitConstructorDecl(ConstructorDecl* decl)
{
// We need to compute the result tyep for this declaration,
// since it wasn't filled in for us.
decl->returnType.type = findResultTypeForConstructorDecl(decl);
checkCallableDeclCommon(decl);
}
void SemanticsDeclHeaderVisitor::visitAbstractStorageDeclCommon(ContainerDecl* decl)
{
// If we have a subscript or property declaration with no accessor declarations,
// then we should create a single `GetterDecl` to represent
// the implicit meaning of their declaration, so:
//
// subscript(uint index) -> T;
// property x : Y;
//
// becomes:
//
// subscript(uint index) -> T { get; }
// property x : Y { get; }
//
bool anyAccessors = decl->getMembersOfType<AccessorDecl>().isNonEmpty();
if(!anyAccessors)
{
GetterDecl* getterDecl = m_astBuilder->create<GetterDecl>();
getterDecl->loc = decl->loc;
getterDecl->parentDecl = decl;
decl->members.add(getterDecl);
}
}
void SemanticsDeclHeaderVisitor::visitSubscriptDecl(SubscriptDecl* decl)
{
decl->returnType = CheckUsableType(decl->returnType);
visitAbstractStorageDeclCommon(decl);
checkCallableDeclCommon(decl);
}
void SemanticsDeclHeaderVisitor::visitPropertyDecl(PropertyDecl* decl)
{
decl->type = CheckUsableType(decl->type);
visitAbstractStorageDeclCommon(decl);
checkVisibility(decl);
}
Type* SemanticsDeclHeaderVisitor::_getAccessorStorageType(AccessorDecl* decl)
{
auto parentDecl = decl->parentDecl;
if (auto parentSubscript = as<SubscriptDecl>(parentDecl))
{
ensureDecl(parentSubscript, DeclCheckState::CanUseTypeOfValueDecl);
return parentSubscript->returnType;
}
else if (auto parentProperty = as<PropertyDecl>(parentDecl))
{
ensureDecl(parentProperty, DeclCheckState::CanUseTypeOfValueDecl);
return parentProperty->type.type;
}
else
{
return getASTBuilder()->getErrorType();
}
}
void SemanticsDeclHeaderVisitor::_visitAccessorDeclCommon(AccessorDecl* decl)
{
// An accessor must appear nested inside a subscript or property declaration.
//
auto parentDecl = decl->parentDecl;
if (as<SubscriptDecl>(parentDecl))
{}
else if (as<PropertyDecl>(parentDecl))
{}
else
{
getSink()->diagnose(decl, Diagnostics::accessorMustBeInsideSubscriptOrProperty);
}
}
void SemanticsDeclHeaderVisitor::visitAccessorDecl(AccessorDecl* decl)
{
_visitAccessorDeclCommon(decl);
// Note: This subroutine is used by both `get`
// and `ref` accessors, but is bypassed by
// `set` accessors (which use `visitSetterDecl`
// intead).
// Accessors (other than setters) don't support
// parameters.
//
if( decl->getParameters().getCount() != 0 )
{
getSink()->diagnose(decl, Diagnostics::nonSetAccessorMustNotHaveParams);
}
// By default, the return type of an accessor is treated as
// the type of the abstract storage location being accessed.
//
// A `ref` accessor currently relies on this logic even though
// it isn't quite correct, because we don't have support
// for by-reference return values today. This is a non-issue
// for now because we don't support user-defined `ref`
// accessors yet.
//
// TODO: Once we can support the by-reference return value
// correctly *or* we can move to something like a coroutine-based
// `modify` accessor (a la Swift), we should split out
// handling of `RefAccessorDecl` and only use this routine
// for `GetterDecl`s.
//
decl->returnType.type = _getAccessorStorageType(decl);
}
void SemanticsDeclHeaderVisitor::visitSetterDecl(SetterDecl* decl)
{
// Make sure to invoke the common checking logic for all accessors.
_visitAccessorDeclCommon(decl);
// A `set` accessor always returns `void`.
//
decl->returnType.type = getASTBuilder()->getVoidType();
// A setter always receives a single value representing
// the new value to set into the storage.
//
// The user may declare that parameter explicitly and
// thereby control its name, or they can declare no
// parmaeters and allow the compiler to synthesize one
// names `newValue`.
//
ParamDecl* newValueParam = nullptr;
auto params = decl->getParameters();
if( params.getCount() >= 1 )
{
// If the user declared an explicit parameter
// then that is the one that will represent
// the new value.
//
newValueParam = params.getFirst();
if( params.getCount() > 1 )
{
// If the user declared more than one explicit
// parameter, then that is an error.
//
getSink()->diagnose(params[1], Diagnostics::setAccessorMayNotHaveMoreThanOneParam);
}
}
else
{
// If the user didn't declare any explicit parameters,
// then we create an implicit one and add it into
// the AST.
//
newValueParam = m_astBuilder->create<ParamDecl>();
newValueParam->nameAndLoc.name = getName("newValue");
newValueParam->nameAndLoc.loc = decl->loc;
newValueParam->parentDecl = decl;
decl->members.add(newValueParam);
}
// The new-value parameter is expected to have the
// same type as the abstract storage that the
// accessor is setting.
//
auto newValueType = _getAccessorStorageType(decl);
// It is allowed and encouraged for the programmer
// to leave off the type on the new-value parameter,
// in which case we will set it to the expected
// type automatically.
//
if( !newValueParam->type.exp )
{
newValueParam->type.type = newValueType;
}
else
{
// If the user *did* give the new-value parameter
// an explicit type, then we need to check it
// and then enforce that it matches what we expect.
//
auto actualType = CheckProperType(newValueParam->type);
if(as<ErrorType>(actualType))
{}
else if(actualType->equals(newValueType))
{}
else
{
getSink()->diagnose(newValueParam, Diagnostics::setAccessorParamWrongType, newValueParam, actualType, newValueType);
}
}
}
GenericDecl* SemanticsVisitor::GetOuterGeneric(Decl* decl)
{
auto parentDecl = decl->parentDecl;
if (!parentDecl) return nullptr;
auto parentGeneric = as<GenericDecl>(parentDecl);
return parentGeneric;
}
Decl* SemanticsVisitor::getOuterGenericOrSelf(Decl* decl)
{
auto parentDecl = decl->parentDecl;
if (!parentDecl) return decl;
auto parentGeneric = as<GenericDecl>(parentDecl);
if (!parentGeneric) return decl;
return parentGeneric;
}
GenericDecl* SemanticsVisitor::findNextOuterGeneric(Decl* decl)
{
for (auto p = decl->parentDecl; p; p = p->parentDecl)
{
if (auto genDecl = as<GenericDecl>(p))
return genDecl;
}
return nullptr;
}
DeclRef<ExtensionDecl> SemanticsVisitor::applyExtensionToType(
ExtensionDecl* extDecl,
Type* type)
{
DeclRef<ExtensionDecl> extDeclRef = makeDeclRef(extDecl);
// If the extension is a generic extension, then we
// need to infer type arguments that will give
// us a target type that matches `type`.
//
if (auto extGenericDecl = GetOuterGeneric(extDecl))
{
ConstraintSystem constraints;
constraints.loc = extDecl->loc;
constraints.genericDecl = extGenericDecl;
// Inside the body of an extension declaration, we may end up trying to apply that
// extension to its own target type.
// If we see that we are in that case, we can apply the extension declaration as - is,
// without any additional substitutions.
if (extDecl->targetType->equals(type))
{
/*
auto subst = trySolveConstraintSystem(
&constraints,
DeclRef<Decl>(extGenericDecl, nullptr).as<GenericDecl>(),
as<GenericSubstitution>(as<DeclRefType>(type)->declRef.substitutions.substitutions));
return DeclRef<Decl>(extDecl, subst).as<ExtensionDecl>();
*/
return createDefaultSubstitutionsIfNeeded(m_astBuilder, this, extDeclRef).as<ExtensionDecl>();
}
if (!TryUnifyTypes(constraints, extDecl->targetType.Ptr(), type))
return DeclRef<ExtensionDecl>();
ConversionCost baseCost;
auto solvedDeclRef = trySolveConstraintSystem(&constraints, makeDeclRef(extGenericDecl), ArrayView<Val*>(), baseCost);
if (!solvedDeclRef)
{
return DeclRef<ExtensionDecl>();
}
// Construct a reference to the extension with our constraint variables
// set as they were found by solving the constraint system.
extDeclRef = solvedDeclRef.as<ExtensionDecl>();
}
// Now extract the target type from our (possibly specialized) extension decl-ref.
Type* targetType = getTargetType(m_astBuilder, extDeclRef);
// As a bit of a kludge here, if the target type of the extension is
// an interface, and the `type` we are trying to match up has a this-type
// substitution for that interface, then we want to attach a matching
// substitution to the extension decl-ref.
if(auto targetDeclRefType = as<DeclRefType>(targetType))
{
if(auto targetInterfaceDeclRef = targetDeclRefType->getDeclRef().as<InterfaceDecl>())
{
// Okay, the target type is an interface.
//
// Is the type we want to apply to a ThisType?
if(auto appDeclRefType = as<ThisType>(type))
{
if(auto thisTypeLookupDeclRef = SubstitutionSet(appDeclRefType->getDeclRef()).findLookupDeclRef())
{
if(thisTypeLookupDeclRef->getDecl() == targetInterfaceDeclRef.getDecl())
{
// Looks like we have a match in the types,
// now let's see if `type`'s declref starts with a Lookup.
targetType = type;
extDeclRef = m_astBuilder->getLookupDeclRef(thisTypeLookupDeclRef->getWitness(), extDeclRef.getDecl());
}
}
}
}
}
// In order for this extension to apply to the given type, we
// need to have a match on the target types.
if (!type->equals(targetType))
return DeclRef<ExtensionDecl>();
return extDeclRef;
}
QualType SemanticsVisitor::GetTypeForDeclRef(DeclRef<Decl> declRef, SourceLoc loc)
{
Type* typeResult = nullptr;
return getTypeForDeclRef(
m_astBuilder,
this,
getSink(),
declRef,
&typeResult,
loc);
}
void SemanticsVisitor::importFileDeclIntoScope(Scope* scope, FileDecl* fileDecl)
{
// Create a new sub-scope to wire the module
// into our lookup chain.
if (!fileDecl)
return;
addSiblingScopeForContainerDecl(getASTBuilder(), scope, fileDecl);
}
void SemanticsVisitor::importModuleIntoScope(Scope* scope, ModuleDecl* moduleDecl)
{
if (!moduleDecl)
return;
// If we've imported this one already, then
// skip the step where we modify the current scope.
auto& importedModulesList = getShared()->importedModulesList;
auto& importedModulesSet = getShared()->importedModulesSet;
if (importedModulesSet.contains(moduleDecl))
{
return;
}
importedModulesList.add(moduleDecl);
importedModulesSet.add(moduleDecl);
// Create a new sub-scope to wire the module's scope and its nested FileDecl's scopes
// into our lookup chain.
for (auto moduleScope = moduleDecl->ownedScope; moduleScope; moduleScope = moduleScope->nextSibling)
{
if (moduleScope->containerDecl != moduleDecl && moduleScope->containerDecl->parentDecl != moduleDecl)
continue;
addSiblingScopeForContainerDecl(getASTBuilder(), scope, moduleScope->containerDecl);
}
// Also import any modules from nested `import` declarations
// with the `__exported` modifier
for (auto importDecl : moduleDecl->getMembersOfType<ImportDecl>())
{
if (!importDecl->hasModifier<ExportedModifier>())
continue;
importModuleIntoScope(scope, importDecl->importedModuleDecl);
}
}
void SemanticsDeclHeaderVisitor::visitImportDecl(ImportDecl* decl)
{
// We need to look for a module with the specified name
// (whether it has already been loaded, or needs to
// be loaded), and then put its declarations into
// the module's scope.
auto name = decl->moduleNameAndLoc.name;
auto scope = getModuleDecl(decl)->ownedScope;
// Try to load a module matching the name
auto importedModule = findOrImportModule(
getLinkage(),
name,
decl->moduleNameAndLoc.loc,
getSink(),
getShared()->m_environmentModules);
// If we didn't find a matching module, then bail out
if (!importedModule)
return;
// Record the module that was imported, so that we can use
// it later during code generation.
auto importedModuleDecl = importedModule->getModuleDecl();
decl->importedModuleDecl = importedModuleDecl;
// Add the declarations from the imported module into the scope
// that the `import` declaration is set to extend.
//
importModuleIntoScope(scope, importedModuleDecl);
// Record the `import`ed module (and everything it depends on)
// as a dependency of the module we are compiling.
if(auto module = getModule(decl))
{
module->addModuleDependency(importedModule);
}
}
String getSimpleModuleName(Name* name)
{
auto text = getText(name);
auto dirPos = Math::Max(text.indexOf('/'), text.indexOf('\\'));
if (dirPos < 0)
return text;
auto slice = text.getUnownedSlice().tail(dirPos + 1);
auto dotPos = slice.indexOf('.');
if (dotPos < 0)
return slice;
return String(slice.head(dotPos));
}
ModuleDeclarationDecl* findExistingModuleDeclarationDecl(ModuleDecl* decl)
{
if (decl->members.getCount() == 0)
return nullptr;
if (auto rs = as<ModuleDeclarationDecl>(decl->members[0]))
return rs;
for (auto fileDecl : decl->getMembersOfType<FileDecl>())
{
if (fileDecl->members.getCount() == 0)
continue;
if (auto rs = as<ModuleDeclarationDecl>(fileDecl->members[0]))
return rs;
}
return nullptr;
}
void SemanticsDeclHeaderVisitor::visitIncludeDecl(IncludeDecl* decl)
{
auto name = decl->moduleNameAndLoc.name;
if (!getShared()->getTranslationUnitRequest())
getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::cannotProcessInclude);
auto parentModule = getModule(decl);
auto moduleDecl = parentModule->getModuleDecl();
auto [fileDecl, isNew] = getLinkage()->findAndIncludeFile(getModule(decl), getShared()->getTranslationUnitRequest(), name, decl->moduleNameAndLoc.loc, getSink());
if (!fileDecl)
return;
decl->fileDecl = fileDecl;
if (!isNew)
return;
if (fileDecl->members.getCount() == 0)
return;
auto firstMember = fileDecl->members[0];
if (auto moduleDeclaration = as<ModuleDeclarationDecl>(firstMember))
{
// We are trying to include a file that defines a module, the user could mean "import" instead.
getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::includedFileMissingImplementingDoYouMeanImport, name, moduleDeclaration->getName());
return;
}
importFileDeclIntoScope(moduleDecl->ownedScope, fileDecl);
if (auto implementing = as<ImplementingDecl>(firstMember))
{
// The file we are including must be implementing the current module.
auto moduleName = getSimpleModuleName(implementing->moduleNameAndLoc.name);
auto expectedModuleName = moduleDecl->getName();
bool shouldSkipDiagnostic = false;
if (moduleDecl->members.getCount())
{
if (auto moduleDeclarationDecl = as<ModuleDeclarationDecl>(moduleDecl->members[0]))
{
expectedModuleName = moduleDeclarationDecl->getName();
}
else if (getShared()->isInLanguageServer())
{
auto moduleDeclarationDecls = findExistingModuleDeclarationDecl(moduleDecl);
if (moduleDeclarationDecls)
{
expectedModuleName = moduleDeclarationDecls->getName();
}
else
{
shouldSkipDiagnostic = true;
}
}
}
if (!shouldSkipDiagnostic && !moduleName.getUnownedSlice().caseInsensitiveEquals(getText(expectedModuleName).getUnownedSlice()))
{
getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::includedFileDoesNotImplementCurrentModule, expectedModuleName, moduleName);
return;
}
return;
}
getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::includedFileMissingImplementing, name);
}
void SemanticsDeclScopeWiringVisitor::visitImplementingDecl(ImplementingDecl* decl)
{
// Don't need to do anything unless we are in a language server context.
if (!getShared()->isInLanguageServer())
return;
// Treat an `implementing` declaration as an `include` declaration when
// we are in a language server context.
auto name = decl->moduleNameAndLoc.name;
if (!getShared()->getTranslationUnitRequest())
getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::cannotProcessInclude);
auto [fileDecl, isNew] = getLinkage()->findAndIncludeFile(getModule(decl), getShared()->getTranslationUnitRequest(), name, decl->moduleNameAndLoc.loc, getSink());
decl->fileDecl = fileDecl;
if (!isNew)
return;
if (!fileDecl || fileDecl->members.getCount() == 0)
{
return;
}
auto firstMember = fileDecl->members[0];
if (as<ModuleDeclarationDecl>(firstMember))
{
// We are trying to implement a file that defines a module, this is expected.
}
else if (as<ImplementingDecl>(firstMember))
{
getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::implementingMustReferencePrimaryModuleFile);
return;
}
if (auto moduleDecl = getModuleDecl(decl))
importFileDeclIntoScope(moduleDecl->ownedScope, fileDecl);
}
void SemanticsDeclScopeWiringVisitor::visitUsingDecl(UsingDecl* decl)
{
// First, we need to look up whatever the argument of the `using`
// declaration names.
//
decl->arg = CheckTerm(decl->arg);
// Next, we want to ensure that whatever is being named by `decl->arg`
// is a namespace (or a module, since modules are namespace-like).
//
// If a user `import`s multiple modules that all have namespaces
// of the same name, it would be possible for `decl->arg` to be overloaded.
// To handle that case, we will iterate over all the entities that are
// named and import any that are namespace-like.
//
bool scopesAdded = false;
bool hasValidNamespace = false;
// TODO: consider caching the scope set in NamespaceDecl.
HashSet<ContainerDecl*> addedScopes;
for (auto s = decl->scope; s; s = s->nextSibling)
addedScopes.add(s->containerDecl);
auto addAllSiblingScopesFromDecl = [&](Scope* scope, ContainerDecl* containerDecl)
{
for (auto s = containerDecl->ownedScope; s; s = s->nextSibling)
{
if (addedScopes.add(s->containerDecl))
{
scopesAdded = true;
addSiblingScopeForContainerDecl(getASTBuilder(), scope, s->containerDecl);
}
}
};
if (auto declRefExpr = as<DeclRefExpr>(decl->arg))
{
if (auto namespaceDeclRef = declRefExpr->declRef.as<NamespaceDeclBase>())
{
auto namespaceDecl = namespaceDeclRef.getDecl();
addAllSiblingScopesFromDecl(decl->scope, namespaceDecl);
hasValidNamespace = true;
}
}
else if (auto overloadedExpr = as<OverloadedExpr>(decl->arg))
{
for (auto item : overloadedExpr->lookupResult2)
{
if (auto namespaceDeclRef = item.declRef.as<NamespaceDeclBase>())
{
addAllSiblingScopesFromDecl(decl->scope, namespaceDeclRef.getDecl());
hasValidNamespace = true;
}
}
}
if (!scopesAdded)
{
if (!hasValidNamespace)
getSink()->diagnose(decl->arg, Diagnostics::expectedANamespace, decl->arg->type);
return;
}
}
void SemanticsDeclScopeWiringVisitor::visitNamespaceDecl(NamespaceDecl* decl)
{
// We need to wire up the scope of namespaces with other namespace decls of the same name
// that is accessible from the current context.
auto parent = as<ContainerDecl>(getParentDecl(decl));
if (!parent)
return;
for (auto parentScope = parent->ownedScope; parentScope; parentScope = parentScope->parent)
{
for (auto scope = parentScope; scope; scope = scope->nextSibling)
{
auto container = scope->containerDecl;
auto nsDeclPtr = container->getMemberDictionary().tryGetValue(decl->getName());
if (!nsDeclPtr) continue;
auto nsDecl = *nsDeclPtr;
for (auto ns = nsDecl; ns; ns = ns->nextInContainerWithSameName)
{
if (ns == decl)
continue;
auto otherNamespace = as<NamespaceDeclBase>(ns);
if (!otherNamespace)
continue;
if (!ns->checkState.isBeingChecked())
{
ensureDecl(ns, DeclCheckState::ScopesWired);
}
addSiblingScopeForContainerDecl(getASTBuilder(), decl, otherNamespace);
}
}
// For file decls, we need to continue searching up in the parent module scope.
if (!as<FileDecl>(parentScope->containerDecl))
break;
}
for (auto usingDecl : decl->getMembersOfType<UsingDecl>())
{
ensureDecl(usingDecl, DeclCheckState::ScopesWired);
}
}
/// Get a reference to the candidate extension list for `typeDecl` in the given dictionary
///
/// Note: this function creates an empty list of candidates for the given type if
/// a matching entry doesn't exist already.
///
static List<ExtensionDecl*>& _getCandidateExtensionList(
AggTypeDecl* typeDecl,
Dictionary<AggTypeDecl*, RefPtr<CandidateExtensionList>>& mapTypeToCandidateExtensions)
{
RefPtr<CandidateExtensionList> entry;
if( !mapTypeToCandidateExtensions.tryGetValue(typeDecl, entry) )
{
entry = new CandidateExtensionList();
mapTypeToCandidateExtensions.add(typeDecl, entry);
}
return entry->candidateExtensions;
}
List<ExtensionDecl*> const& SharedSemanticsContext::getCandidateExtensionsForTypeDecl(AggTypeDecl* decl)
{
// We are caching the lists of candidate extensions on the shared
// context, so we will only build the lists if they either have
// not been built before, or if some code caused the lists to
// be invalidated.
//
// TODO: Similar to the rebuilding of lookup tables in `ContainerDecl`s,
// we probably want to optimize this logic to gracefully handle new
// extensions encountered during checking instead of tearing the whole
// thing down. For now this potentially-quadratic behavior is acceptable
// because there just aren't that many extension declarations being used.
//
if( !m_candidateExtensionListsBuilt )
{
m_candidateExtensionListsBuilt = true;
// We need to make sure that all extensions that were declared
// as part of our standard-library modules are always visible,
// even if they are not explicit `import`ed into user code.
//
for( auto module : getSession()->stdlibModules )
{
_addCandidateExtensionsFromModule(module->getModuleDecl());
}
// There are two primary modes in which the `SharedSemanticsContext`
// gets used.
//
// In the first mode, we are checking an entire `ModuelDecl`, and we
// need to always check things from the "point of view" of that module
// (so that the extensions that should be visible are based on what
// that module can access via `import`s).
//
// In the second mode, we are checking code related to API interactions
// by the user (e.g., parsing a type from a string, specializing an
// entry point to type arguments, etc.). In these cases there is no
// clear module that should determine the point of view for looking
// up extensions, and we instead need/want to consider any extensions
// from all modules loaded into the linkage.
//
// We differentiate these cases based on whether a "primary" module
// was set at the time the `SharedSemanticsContext` was constructed.
//
if( m_module )
{
// We have a "primary" module that is being checked, and we should
// look up extensions based on what would be visible to that
// module.
//
// We need to consider the extensions declared in the module itself,
// along with everything the module imported.
//
// Note: there is an implicit assumption here that the `importedModules`
// member on the `SharedSemanticsContext` is accurate in this case.
//
_addCandidateExtensionsFromModule(m_module->getModuleDecl());
for( auto moduleDecl : this->importedModulesList )
{
_addCandidateExtensionsFromModule(moduleDecl);
}
}
else
{
// We are in one of the many ad hoc checking modes where we really
// want to resolve things based on the totality of what is
// available/defined within the current linkage.
//
for( auto module : m_linkage->loadedModulesList )
{
_addCandidateExtensionsFromModule(module->getModuleDecl());
}
}
}
// Once we are sure that the dictionary-of-arrays of extensions
// has been populated, we return to the user the entry they
// asked for.
//
return _getCandidateExtensionList(decl, m_mapTypeDeclToCandidateExtensions);
}
void SharedSemanticsContext::registerCandidateExtension(AggTypeDecl* typeDecl, ExtensionDecl* extDecl)
{
// The primary cache of extension declarations is on the `ModuleDecl`.
// We will add the `extDecl` to the cache for the module it belongs to.
//
// We can be sure that the resulting cache won't have lifetime issues,
// because all the extensions it contains are owned by the module itself,
// and the types used as keys had to be reachable/referenceable from the
// code inside the module for the given `extDecl` to extend them.
//
auto moduleDecl = getModuleDecl(extDecl);
_getCandidateExtensionList(typeDecl, moduleDecl->mapTypeToCandidateExtensions).add(extDecl);
// Because we've loaded a new extension, we need to invalidate whatever
// information the `SharedSemanticsContext` had cached about loaded
// extensions, and force it to rebuild its cache to include the
// new extension we just added.
//
// TODO: We should probably just go ahead and add `extDecl` directly
// into the appropriate entry here, and do a similar step on each
// `import`.
//
m_candidateExtensionListsBuilt = false;
m_mapTypeDeclToCandidateExtensions.clear();
// Invalidate the cached inheritanceInfo.
m_mapTypeToInheritanceInfo.clear();
m_mapDeclRefToInheritanceInfo.clear();
m_mapTypePairToSubtypeWitness.clear();
}
void SharedSemanticsContext::_addCandidateExtensionsFromModule(ModuleDecl* moduleDecl)
{
for( auto& [entryKey, entryValue] : moduleDecl->mapTypeToCandidateExtensions )
{
auto& list = _getCandidateExtensionList(entryKey, m_mapTypeDeclToCandidateExtensions);
list.addRange(entryValue->candidateExtensions);
}
}
/// Get a reference to the associated decl list for `decl` in the given dictionary
///
/// Note: this function creates an empty list of candidates for the given type if
/// a matching entry doesn't exist already.
///
static List<RefPtr<DeclAssociation>>& _getDeclAssociationList(
Decl* decl,
OrderedDictionary<Decl*, RefPtr<DeclAssociationList>>& mapDeclToDeclarations)
{
RefPtr<DeclAssociationList> entry;
if (!mapDeclToDeclarations.tryGetValue(decl, entry))
{
entry = new DeclAssociationList();
mapDeclToDeclarations.add(decl, entry);
}
return entry->associations;
}
void SharedSemanticsContext::_addDeclAssociationsFromModule(ModuleDecl* moduleDecl)
{
for (auto& entry : moduleDecl->mapDeclToAssociatedDecls)
{
auto& list = _getDeclAssociationList(entry.key, m_mapDeclToAssociatedDecls);
list.addRange(entry.value->associations);
}
}
void SharedSemanticsContext::registerAssociatedDecl(Decl* original, DeclAssociationKind kind, Decl* associated)
{
auto moduleDecl = getModuleDecl(associated);
RefPtr<DeclAssociation> assoc = new DeclAssociation();
assoc->kind = kind;
assoc->decl = associated;
_getDeclAssociationList(original, moduleDecl->mapDeclToAssociatedDecls).add(assoc);
m_associatedDeclListsBuilt = false;
m_mapDeclToAssociatedDecls.clear();
}
List<RefPtr<DeclAssociation>> const& SharedSemanticsContext::getAssociatedDeclsForDecl(Decl* decl)
{
// This duplicates the exact same logic from `getCandidateExtensionsForTypeDecl`.
// Consider refactoring them into the same framework.
if (!m_associatedDeclListsBuilt)
{
m_associatedDeclListsBuilt = true;
for (auto module : getSession()->stdlibModules)
{
_addDeclAssociationsFromModule(module->getModuleDecl());
}
if (m_module)
{
_addDeclAssociationsFromModule(m_module->getModuleDecl());
for (auto moduleDecl : this->importedModulesList)
{
_addDeclAssociationsFromModule(moduleDecl);
}
}
else
{
for (auto module : m_linkage->loadedModulesList)
{
_addDeclAssociationsFromModule(module->getModuleDecl());
}
}
}
return _getDeclAssociationList(decl, m_mapDeclToAssociatedDecls);
}
bool SharedSemanticsContext::isDifferentiableFunc(FunctionDeclBase* func)
{
return getFuncDifferentiableLevel(func) != FunctionDifferentiableLevel::None;
}
bool SharedSemanticsContext::isBackwardDifferentiableFunc(FunctionDeclBase* func)
{
return getFuncDifferentiableLevel(func) == FunctionDifferentiableLevel::Backward;
}
FunctionDifferentiableLevel SharedSemanticsContext::getFuncDifferentiableLevel(FunctionDeclBase* func)
{
return _getFuncDifferentiableLevelImpl(func, 1);
}
FunctionDifferentiableLevel SharedSemanticsContext::_getFuncDifferentiableLevelImpl(FunctionDeclBase* func, int recurseLimit)
{
if (!func)
return FunctionDifferentiableLevel::None;
if (recurseLimit > 0)
{
if (auto primalSubst = func->findModifier<PrimalSubstituteAttribute>())
{
if (auto declRefExpr = as<DeclRefExpr>(primalSubst->funcExpr))
{
if (auto primalSubstFunc = declRefExpr->declRef.as<FunctionDeclBase>())
return _getFuncDifferentiableLevelImpl(primalSubstFunc.getDecl(), recurseLimit - 1);
}
}
}
if (func->findModifier<BackwardDifferentiableAttribute>())
return FunctionDifferentiableLevel::Backward;
if (func->findModifier<BackwardDerivativeAttribute>())
return FunctionDifferentiableLevel::Backward;
if (func->findModifier<TreatAsDifferentiableAttribute>())
return FunctionDifferentiableLevel::Backward;
FunctionDifferentiableLevel diffLevel = FunctionDifferentiableLevel::None;
if (func->findModifier<DifferentiableAttribute>())
diffLevel = FunctionDifferentiableLevel::Forward;
for (auto assocDecl : getAssociatedDeclsForDecl(func))
{
switch (assocDecl->kind)
{
case DeclAssociationKind::BackwardDerivativeFunc:
return FunctionDifferentiableLevel::Backward;
case DeclAssociationKind::ForwardDerivativeFunc:
diffLevel = FunctionDifferentiableLevel::Forward;
break;
case DeclAssociationKind::PrimalSubstituteFunc:
if (auto assocFunc = as<FunctionDeclBase>(assocDecl->decl))
{
return _getFuncDifferentiableLevelImpl(assocFunc, recurseLimit - 1);
}
break;
default:
break;
}
}
if (auto builtinReq = func->findModifier<BuiltinRequirementModifier>())
{
switch (builtinReq->kind)
{
case BuiltinRequirementKind::DAddFunc:
case BuiltinRequirementKind::DMulFunc:
case BuiltinRequirementKind::DZeroFunc:
return FunctionDifferentiableLevel::Backward;
default:
break;
}
}
return diffLevel;
}
List<ExtensionDecl*> const& getCandidateExtensions(
DeclRef<AggTypeDecl> const& declRef,
SemanticsVisitor* semantics)
{
auto decl = declRef.getDecl();
auto shared = semantics->getShared();
return shared->getCandidateExtensionsForTypeDecl(decl);
}
void _foreachDirectOrExtensionMemberOfType(
SemanticsVisitor* semantics,
DeclRef<ContainerDecl> const& containerDeclRef,
SyntaxClassBase const& syntaxClass,
void (*callback)(DeclRefBase*, void*),
void const* userData)
{
// We are being asked to invoke the given callback on
// each direct member of `containerDeclRef`, along with
// any members added via `extension` declarations, that
// have the correct AST node class (`syntaxClass`).
//
// We start with the direct members.
//
for( auto memberDeclRef : getMembers(semantics->getASTBuilder(), containerDeclRef))
{
if( memberDeclRef.getDecl()->getClass().isSubClassOfImpl(syntaxClass))
{
callback(memberDeclRef, (void*)userData);
}
}
// Next, in the case wher ethe type can be subject to extensions,
// we loop over the applicable extensions and their member.s
//
if(auto aggTypeDeclRef = containerDeclRef.as<AggTypeDecl>())
{
auto aggType = DeclRefType::create(semantics->getASTBuilder(), aggTypeDeclRef);
for(auto extDecl : getCandidateExtensions(aggTypeDeclRef, semantics))
{
// Note that `extDecl` may have been declared for a type
// base on the declaration that `aggTypeDeclRef` refers
// to, but that does not guarantee that it applies to
// the type itself. E.g., we might have an extension of
// `vector<float, N>` for any `N`, but the current type is
// `vector<int, 2>` so that the extension doesn't match.
//
// In order to make sure that we don't enumerate members
// that don't make sense in context, we must apply
// the extension to the type and see if we succeed in
// making a match.
//
auto extDeclRef = applyExtensionToType(semantics, extDecl, aggType);
if(!extDeclRef)
continue;
for( auto memberDeclRef : getMembers(semantics->getASTBuilder(), extDeclRef) )
{
if( memberDeclRef.getDecl()->getClass().isSubClassOfImpl(syntaxClass))
{
callback(memberDeclRef, (void*)userData);
}
}
}
}
}
static void _dispatchDeclCheckingVisitor(Decl* decl, DeclCheckState state, SemanticsContext const& shared)
{
switch(state)
{
case DeclCheckState::ModifiersChecked:
SemanticsDeclModifiersVisitor(shared).dispatch(decl);
break;
case DeclCheckState::ScopesWired:
SemanticsDeclScopeWiringVisitor(shared).dispatch(decl);
break;
case DeclCheckState::SignatureChecked:
SemanticsDeclHeaderVisitor(shared).dispatch(decl);
break;
case DeclCheckState::ReadyForReference:
SemanticsDeclRedeclarationVisitor(shared).dispatch(decl);
break;
case DeclCheckState::ReadyForLookup:
SemanticsDeclBasesVisitor(shared).dispatch(decl);
break;
case DeclCheckState::ReadyForConformances:
SemanticsDeclConformancesVisitor(shared).dispatch(decl);
break;
case DeclCheckState::TypesFullyResolved:
SemanticsDeclTypeResolutionVisitor(shared).dispatch(decl);
SemanticsDeclDifferentialConformanceVisitor(shared).dispatch(decl);
break;
case DeclCheckState::AttributesChecked:
SemanticsDeclAttributesVisitor(shared).dispatch(decl);
break;
case DeclCheckState::DefinitionChecked:
SemanticsDeclBodyVisitor(shared).dispatch(decl);
break;
case DeclCheckState::CapabilityChecked:
SemanticsDeclCapabilityVisitor(shared).dispatch(decl);
break;
}
}
static void _getCanonicalConstraintTypes(List<Type*>& outTypeList, Type* type)
{
if (auto andType = as<AndType>(type))
{
_getCanonicalConstraintTypes(outTypeList, andType->getLeft());
_getCanonicalConstraintTypes(outTypeList, andType->getRight());
}
else
{
outTypeList.add(type);
}
}
OrderedDictionary<GenericTypeParamDecl*, List<Type*>> getCanonicalGenericConstraints(
ASTBuilder* astBuilder,
DeclRef<ContainerDecl> genericDecl)
{
OrderedDictionary<GenericTypeParamDecl*, List<Type*>> genericConstraints;
for (auto mm : getMembersOfType<GenericTypeParamDecl>(astBuilder, genericDecl))
{
genericConstraints[mm.getDecl()] = List<Type*>();
}
for (auto genericTypeConstraintDecl : getMembersOfType<GenericTypeConstraintDecl>(astBuilder, genericDecl))
{
assert(
genericTypeConstraintDecl.getDecl()->sub.type->astNodeType ==
ASTNodeType::DeclRefType);
auto typeParamDecl = as<DeclRefType>(genericTypeConstraintDecl.getDecl()->sub.type)->getDeclRef().getDecl();
List<Type*>* constraintTypes = genericConstraints.tryGetValue(typeParamDecl);
assert(constraintTypes);
constraintTypes->add(genericTypeConstraintDecl.getDecl()->getSup().type);
}
OrderedDictionary<GenericTypeParamDecl*, List<Type*>> result;
for (auto& constraints : genericConstraints)
{
List<Type*> typeList;
for (auto type : constraints.value)
{
_getCanonicalConstraintTypes(typeList, type);
}
// TODO: we also need to sort the types within the list for each generic type param.
result[constraints.key] = typeList;
}
return result;
}
struct ArgsWithDirectionInfo
{
List<Expr*> args;
List<ParameterDirection> directions;
};
template<typename TDerivativeAttr>
void checkDerivativeAttributeImpl(
SemanticsVisitor* visitor,
Decl* funcDecl,
TDerivativeAttr* attr,
const List<Expr*>& imaginaryArguments,
const List<ParameterDirection>& expectedParamDirections)
{
if (isInterfaceRequirement(funcDecl))
{
visitor->getSink()->diagnose(attr, Diagnostics::cannotAssociateInterfaceRequirementWithDerivative);
return;
}
SemanticsContext::ExprLocalScope scope;
auto ctx = visitor->withExprLocalScope(&scope);
auto subVisitor = SemanticsVisitor(ctx);
auto checkedFuncExpr = visitor->dispatchExpr(attr->funcExpr, ctx);
attr->funcExpr = checkedFuncExpr;
if (attr->args.getCount())
attr->args[0] = attr->funcExpr;
if (auto declRefExpr = as<DeclRefExpr>(checkedFuncExpr))
{
if (declRefExpr->declRef)
visitor->ensureDecl(declRefExpr->declRef, DeclCheckState::TypesFullyResolved);
else
{
visitor->getSink()->diagnose(attr, Diagnostics::cannotResolveDerivativeFunction);
return;
}
}
else if (auto overloadedExpr = as<OverloadedExpr>(checkedFuncExpr))
{
for (auto candidate : overloadedExpr->lookupResult2.items)
{
visitor->ensureDecl(candidate.declRef, DeclCheckState::TypesFullyResolved);
}
}
else
{
visitor->getSink()->diagnose(attr, Diagnostics::cannotResolveDerivativeFunction);
return;
}
// If left value is true, then convert the
// inner type to an InOutType.
//
auto qualTypeToString = [&](QualType qualType) -> String
{
Type* type = qualType.type;
if (qualType.isLeftValue)
{
type = ctx.getASTBuilder()->getInOutType(type);
}
return type->toString();
};
auto invokeExpr = subVisitor.constructUncheckedInvokeExpr(checkedFuncExpr, imaginaryArguments);
auto resolved = subVisitor.ResolveInvoke(invokeExpr);
if (auto resolvedInvoke = as<InvokeExpr>(resolved))
{
if (auto calleeDeclRef = as<DeclRefExpr>(resolvedInvoke->functionExpr))
{
// There are two ways to make it to this point.. a proper resolution, and a
// resolution that has failed due to type mismatch.
// Further, a proper resolution can still be invalid due to incorrect parameter
// directionality.
// We'll detect both these incorrect cases here and issue an appropriate diagnostic.
//
auto funcType = as<FuncType>(calleeDeclRef->type);
if (!funcType)
{
// The best candidate does not have a function type.
// If we reach here, it means the function is a generic and we can't deduce the
// generic arguments from imaginary argument list.
// In this case we issue a diagnostic to ask the user to explicitly provide the arguments.
visitor->getSink()->diagnose(attr, Diagnostics::cannotResolveGenericArgumentForDerivativeFunction);
return;
}
if (isInterfaceRequirement(calleeDeclRef->declRef.getDecl()))
{
visitor->getSink()->diagnose(attr, Diagnostics::cannotUseInterfaceRequirementAsDerivative);
return;
}
if (funcType->getParamCount() != imaginaryArguments.getCount())
{
goto error;
}
for (Index ii = 0; ii < imaginaryArguments.getCount(); ++ii)
{
// Check if the resolved invoke argument type is an error type.
// If so, then we have a type mismatch.
//
if (resolvedInvoke->arguments[ii]->type.type->equals(ctx.getASTBuilder()->getErrorType()) ||
funcType->getParamDirection(ii) != expectedParamDirections[ii])
{
visitor->getSink()->diagnose(
attr,
Diagnostics::customDerivativeSignatureMismatchAtPosition,
ii,
qualTypeToString(imaginaryArguments[ii]->type),
funcType->getParamType(ii)->toString());
}
}
// The `imaginaryArguments` list does not include the `this` parameter.
// So we need to check that `this` type matches.
bool funcIsStatic = isEffectivelyStatic(funcDecl);
bool derivativeFuncIsStatic = isEffectivelyStatic(calleeDeclRef->declRef.getDecl());
if (funcIsStatic != derivativeFuncIsStatic)
{
visitor->getSink()->diagnose(
attr,
Diagnostics::customDerivativeSignatureThisParamMismatch);
return;
}
if (!funcIsStatic)
{
auto defaultFuncDeclRef = createDefaultSubstitutionsIfNeeded(
visitor->getASTBuilder(),
visitor,
makeDeclRef(funcDecl));
auto funcThisType = visitor->calcThisType(defaultFuncDeclRef);
auto derivativeFuncThisType = visitor->calcThisType(calleeDeclRef->declRef);
if (!funcThisType->equals(derivativeFuncThisType))
{
visitor->getSink()->diagnose(
attr,
Diagnostics::customDerivativeSignatureThisParamMismatch);
return;
}
if (visitor->isTypeDifferentiable(funcThisType))
{
visitor->getSink()->diagnose(
attr,
Diagnostics::customDerivativeNotAllowedForMemberFunctionsOfDifferentiableType);
return;
}
}
attr->funcExpr = calleeDeclRef;
if (attr->args.getCount())
attr->args[0] = attr->funcExpr;
return;
}
}
error:;
// Build the expected signature from imaginary args to diagnose
// when no matching function is found (this excludes the case handled above)
//
StringBuilder builder;
builder << "(";
for (Index ii = 0; ii < imaginaryArguments.getCount(); ++ii)
{
if (ii != 0)
builder << ", ";
if (imaginaryArguments[ii]->type)
builder << qualTypeToString(imaginaryArguments[ii]->type);
else
builder << "<error>";
}
builder << ")";
visitor->getSink()->diagnose(attr, Diagnostics::customDerivativeSignatureMismatch, builder.produceString());
}
template<typename TDerivativeAttr>
const char* getDerivativeAttrName() { SLANG_UNREACHABLE(""); }
template<>
const char* getDerivativeAttrName<ForwardDerivativeAttribute>()
{
return "ForwardDerivative";
}
template<>
const char* getDerivativeAttrName<BackwardDerivativeAttribute>()
{
return "BackwardDerivative";
}
template<>
const char* getDerivativeAttrName<PrimalSubstituteAttribute>()
{
return "PrimalSubstitute";
}
ArgsWithDirectionInfo getImaginaryArgsToFunc(ASTBuilder* astBuilder, FunctionDeclBase* func, SourceLoc loc)
{
List<Expr*> imaginaryArguments;
List<ParameterDirection> directions;
for (auto param : func->getParameters())
{
auto arg = astBuilder->create<VarExpr>();
arg->declRef = makeDeclRef(param);
arg->type.isLeftValue = param->findModifier<OutModifier>() ? true : false;
arg->type.type = param->getType();
arg->loc = loc;
imaginaryArguments.add(arg);
directions.add(getParameterDirection(param));
}
return { imaginaryArguments, directions };
}
ArgsWithDirectionInfo getImaginaryArgsToForwardDerivative(SemanticsVisitor* visitor, FunctionDeclBase* originalFuncDecl, SourceLoc loc)
{
List<Expr*> imaginaryArguments;
for (auto param : originalFuncDecl->getParameters())
{
auto arg = visitor->getASTBuilder()->create<VarExpr>();
arg->declRef = makeDeclRef(param);
arg->type.isLeftValue = param->findModifier<OutModifier>() ? true : false;
arg->type.type = param->getType();
arg->loc = loc;
if (!param->findModifier<NoDiffModifier>())
{
if (auto pairType = visitor->getDifferentialPairType(param->getType()))
{
arg->type.type = pairType;
}
}
imaginaryArguments.add(arg);
}
// Copy parameter directions as is.
List<ParameterDirection> expectedParamDirections;
for (auto param : originalFuncDecl->getParameters())
{
expectedParamDirections.add(getParameterDirection(param));
}
return { imaginaryArguments, expectedParamDirections };
}
ArgsWithDirectionInfo getImaginaryArgsToBackwardDerivative(SemanticsVisitor* visitor, FunctionDeclBase* originalFuncDecl, SourceLoc loc)
{
List<Expr*> imaginaryArguments;
List<ParameterDirection> expectedParamDirections;
auto isOutParam = [&](ParamDecl* param)
{
return param->findModifier<OutModifier>() != nullptr
&& param->findModifier<InModifier>() == nullptr && param->findModifier<InOutModifier>() == nullptr;
};
for (auto param : originalFuncDecl->getParameters())
{
auto arg = visitor->getASTBuilder()->create<VarExpr>();
arg->declRef = makeDeclRef(param);
arg->type.isLeftValue = param->findModifier<OutModifier>() ? true : false;
arg->type.type = param->getType();
arg->loc = loc;
ParameterDirection direction = getParameterDirection(param);
bool isDiffParam = (!param->findModifier<NoDiffModifier>());
if (isDiffParam)
{
if (auto pairType = as<DifferentialPairType>(visitor->getDifferentialPairType(param->getType())))
{
arg->type.type = pairType;
arg->type.isLeftValue = true;
if (isOutParam(param))
{
// out T : IDifferentiable -> in T.Differential
arg->type.isLeftValue = false;
arg->type.type = visitor->tryGetDifferentialType(
visitor->getASTBuilder(), pairType->getPrimalType());
direction = ParameterDirection::kParameterDirection_In;
}
else
{
// in T : IDifferentiable -> inout DifferentialPair<T>
// inout T : IDifferentiable -> inout DifferentialPair<T>
direction = ParameterDirection::kParameterDirection_InOut;
}
}
else
{
isDiffParam = false;
}
}
if (!isDiffParam)
{
if (isOutParam(param))
{
// Skip non-differentiable out params.
continue;
}
// no_diff inout T -> in T
// no_diff in T -> in T
//
direction = ParameterDirection::kParameterDirection_In;
}
imaginaryArguments.add(arg);
expectedParamDirections.add(direction);
}
if (auto diffReturnType = visitor->tryGetDifferentialType(visitor->getASTBuilder(), originalFuncDecl->returnType.type))
{
auto arg = visitor->getASTBuilder()->create<InitializerListExpr>();
arg->type.isLeftValue = false;
arg->type.type = diffReturnType;
arg->loc = loc;
imaginaryArguments.add(arg);
expectedParamDirections.add(ParameterDirection::kParameterDirection_In);
}
return {imaginaryArguments, expectedParamDirections};
}
// This helper function is needed to workaround a gcc bug.
// Remove when we upgrade to a newer version of gcc.
template <typename T>
static T* _findModifier(Decl* decl)
{
return decl->findModifier<T>();
}
template <typename TDerivativeAttr, typename TDifferentiateExpr, typename TDerivativeOfAttr>
void checkDerivativeOfAttributeImpl(
SemanticsVisitor* visitor,
FunctionDeclBase* funcDecl,
TDerivativeOfAttr* derivativeOfAttr,
DeclAssociationKind assocKind)
{
auto astBuilder = visitor->getASTBuilder();
DeclRef<Decl> calleeDeclRef;
DeclRefExpr* calleeDeclRefExpr = nullptr;
HigherOrderInvokeExpr* higherOrderFuncExpr = astBuilder->create<TDifferentiateExpr>();
higherOrderFuncExpr->baseFunction = derivativeOfAttr->funcExpr;
if (derivativeOfAttr->args.getCount() > 0)
higherOrderFuncExpr->loc = derivativeOfAttr->args[0]->loc;
Expr* checkedHigherOrderFuncExpr = visitor->dispatchExpr(higherOrderFuncExpr, visitor->allowStaticReferenceToNonStaticMember());
if (!checkedHigherOrderFuncExpr)
{
visitor->getSink()->diagnose(derivativeOfAttr, Diagnostics::cannotResolveOriginalFunctionForDerivative);
return;
}
List<Expr*> imaginaryArgs = getImaginaryArgsToFunc(astBuilder, funcDecl, derivativeOfAttr->loc).args;
auto invokeExpr = visitor->constructUncheckedInvokeExpr(checkedHigherOrderFuncExpr, imaginaryArgs);
SemanticsContext::ExprLocalScope scope;
auto ctx = visitor->withExprLocalScope(&scope);
auto subVisitor = SemanticsVisitor(ctx);
auto resolved = subVisitor.ResolveInvoke(invokeExpr);
if (auto resolvedInvoke = as<InvokeExpr>(resolved))
{
auto resolvedFuncExpr = as<HigherOrderInvokeExpr>(resolvedInvoke->functionExpr);
if (resolvedFuncExpr)
calleeDeclRefExpr = as<DeclRefExpr>(resolvedFuncExpr->baseFunction);
}
if (!calleeDeclRefExpr)
{
visitor->getSink()->diagnose(derivativeOfAttr, Diagnostics::cannotResolveOriginalFunctionForDerivative);
return;
}
calleeDeclRefExpr->loc = higherOrderFuncExpr->loc;
if (derivativeOfAttr->args.getCount() > 0)
derivativeOfAttr->args[0] = calleeDeclRefExpr;
calleeDeclRef = calleeDeclRefExpr->declRef;
auto calleeFunc = as<FunctionDeclBase>(calleeDeclRef.getDecl());
if (!calleeFunc)
{
visitor->getSink()->diagnose(derivativeOfAttr, Diagnostics::cannotResolveOriginalFunctionForDerivative);
return;
}
// For now, if calleeFunc or funcDecl is nested inside some generic aggregate,
// they must be the same generic decl. For example, using B<T>.f() as the original function
// for C<T>.derivative() is not allowed.
// We may relax this restriction in the future by solving the "inverse" generic arguments
// from the `calleeDeclRef`, and use them to create a declRef to funcDecl from the original
// func.
auto originalNextGeneric = visitor->findNextOuterGeneric(visitor->getOuterGenericOrSelf(calleeFunc));
auto derivativeNextGeneric = visitor->findNextOuterGeneric(visitor->getOuterGenericOrSelf(funcDecl));
if (originalNextGeneric != derivativeNextGeneric)
{
visitor->getSink()->diagnose(derivativeOfAttr, Diagnostics::cannotResolveGenericArgumentForDerivativeFunction);
return;
}
if (isInterfaceRequirement(calleeFunc))
{
visitor->getSink()->diagnose(derivativeOfAttr, Diagnostics::cannotAssociateInterfaceRequirementWithDerivative);
return;
}
if (isInterfaceRequirement(funcDecl))
{
visitor->getSink()->diagnose(derivativeOfAttr, Diagnostics::cannotUseInterfaceRequirementAsDerivative);
return;
}
if (auto existingModifier = _findModifier<TDerivativeAttr>(calleeFunc))
{
// The primal function already has a `[*Derivative]` attribute, this is invalid.
visitor->getSink()->diagnose(
derivativeOfAttr,
Diagnostics::declAlreadyHasAttribute,
calleeDeclRef,
getDerivativeAttrName<TDerivativeAttr>());
visitor->getSink()->diagnose(existingModifier->loc, Diagnostics::seeDeclarationOf, calleeDeclRef.getDecl());
}
derivativeOfAttr->funcExpr = calleeDeclRefExpr;
auto derivativeAttr = astBuilder->create<TDerivativeAttr>();
derivativeAttr->loc = derivativeOfAttr->loc;
auto outterGeneric = visitor->GetOuterGeneric(funcDecl);
auto declRef = makeDeclRef<Decl>((outterGeneric ? (Decl*)outterGeneric : funcDecl));
// If both the derivative and the original function are defined in the same outer generic
// aggregate type, we want to form a full declref with default arguments.
declRef = createDefaultSubstitutionsIfNeeded(astBuilder, visitor, declRef);
auto declRefExpr = visitor->ConstructDeclRefExpr(declRef, nullptr, derivativeOfAttr->loc, nullptr);
declRefExpr->type.type = nullptr;
derivativeAttr->args.add(declRefExpr);
derivativeAttr->funcExpr = declRefExpr;
checkDerivativeAttribute(visitor, calleeFunc, derivativeAttr);
derivativeOfAttr->backDeclRef = derivativeAttr->funcExpr;
derivativeAttr->funcExpr = nullptr;
visitor->getShared()->registerAssociatedDecl(calleeDeclRef.getDecl(), assocKind, funcDecl);
}
static void checkDerivativeAttribute(SemanticsVisitor* visitor, FunctionDeclBase* funcDecl, ForwardDerivativeAttribute* attr)
{
if (!attr->funcExpr)
return;
if (attr->funcExpr->type.type)
return;
ArgsWithDirectionInfo imaginaryArguments = getImaginaryArgsToForwardDerivative(visitor, funcDecl, attr->loc);
checkDerivativeAttributeImpl(visitor, funcDecl, attr, imaginaryArguments.args, imaginaryArguments.directions);
}
static void checkDerivativeAttribute(SemanticsVisitor* visitor, FunctionDeclBase* funcDecl, BackwardDerivativeAttribute* attr)
{
if (!attr->funcExpr)
return;
if (attr->funcExpr->type.type)
return;
ArgsWithDirectionInfo imaginaryArguments = getImaginaryArgsToBackwardDerivative(visitor, funcDecl, attr->loc);
checkDerivativeAttributeImpl(visitor, funcDecl, attr, imaginaryArguments.args, imaginaryArguments.directions);
}
static void checkDerivativeAttribute(SemanticsVisitor* visitor, FunctionDeclBase* funcDecl, PrimalSubstituteAttribute* attr)
{
if (!attr->funcExpr)
return;
if (attr->funcExpr->type.type)
return;
ArgsWithDirectionInfo imaginaryArguments = getImaginaryArgsToFunc(visitor->getASTBuilder(), funcDecl, attr->loc);
checkDerivativeAttributeImpl(visitor, funcDecl, attr, imaginaryArguments.args, imaginaryArguments.directions);
}
template<typename TDerivativeAttr, typename TDerivativeOfAttr>
bool tryCheckDerivativeOfAttributeImpl(
SemanticsVisitor* visitor,
FunctionDeclBase* funcDecl,
TDerivativeOfAttr* derivativeOfAttr,
DeclAssociationKind assocKind,
const List<Expr*>& imaginaryArgsToOriginal)
{
DiagnosticSink tempSink(visitor->getSourceManager(), nullptr);
SemanticsVisitor subVisitor(visitor->withSink(&tempSink));
checkDerivativeOfAttributeImpl<TDerivativeAttr>(
&subVisitor,
funcDecl,
derivativeOfAttr,
assocKind,
imaginaryArgsToOriginal);
return tempSink.getErrorCount() == 0;
}
void SemanticsDeclAttributesVisitor::checkForwardDerivativeOfAttribute(FunctionDeclBase* funcDecl, ForwardDerivativeOfAttribute* attr)
{
checkDerivativeOfAttributeImpl<ForwardDerivativeAttribute, ForwardDifferentiateExpr>(
this, funcDecl, attr, DeclAssociationKind::ForwardDerivativeFunc);
}
void SemanticsDeclAttributesVisitor::checkBackwardDerivativeOfAttribute(FunctionDeclBase* funcDecl, BackwardDerivativeOfAttribute* attr)
{
checkDerivativeOfAttributeImpl<BackwardDerivativeAttribute, BackwardDifferentiateExpr>(
this, funcDecl, attr, DeclAssociationKind::BackwardDerivativeFunc);
}
void SemanticsDeclAttributesVisitor::checkPrimalSubstituteOfAttribute(FunctionDeclBase* funcDecl, PrimalSubstituteOfAttribute* attr)
{
checkDerivativeOfAttributeImpl<PrimalSubstituteAttribute, PrimalSubstituteExpr>(
this, funcDecl, attr, DeclAssociationKind::PrimalSubstituteFunc);
}
void SemanticsDeclAttributesVisitor::visitStructDecl(StructDecl* structDecl)
{
int backingWidth = 0;
[[maybe_unused]]
int totalWidth = 0;
struct BitFieldInfo
{
int memberIndex;
int bitWidth;
Type* memberType;
BitFieldModifier* bitFieldModifier;
};
List<BitFieldInfo> groupInfo;
int memberIndex = 0;
int backing_nonce = 0;
const auto dispatchSomeBitPackedMembers = [&](){
SLANG_ASSERT(totalWidth <= backingWidth);
SLANG_ASSERT(backingWidth <= 64);
// We're going to insert a backing member to be referenced in
// all the bitfield properties
if(groupInfo.getCount())
{
const auto backingMemberBasicType
= backingWidth <= 8 ? BaseType::UInt8
: backingWidth <= 16 ? BaseType::UInt16
: backingWidth <= 32 ? BaseType::UInt
: BaseType::UInt64;
auto backingMember = m_astBuilder->create<VarDecl>();
backingMember->type.type = m_astBuilder->getBuiltinType(backingMemberBasicType);
backingMember->nameAndLoc.name = getName(String("$bit_field_backing_") + String(backing_nonce));
backing_nonce++;
backingMember->initExpr = nullptr;
backingMember->parentDecl = structDecl;
const auto backingMemberDeclRef = DeclRef<VarDecl>(backingMember->getDefaultDeclRef());
int bottomOfMember = 0;
for(const auto m : groupInfo)
{
SLANG_ASSERT(bottomOfMember <= backingWidth);
m.bitFieldModifier->backingDeclRef = backingMemberDeclRef;
m.bitFieldModifier->offset = bottomOfMember;
bottomOfMember += m.bitWidth;
}
const auto backingMemberIndex = groupInfo[0].memberIndex;
structDecl->members.insert(backingMemberIndex, backingMember);
structDecl->invalidateMemberDictionary();
++memberIndex;
}
structDecl->buildMemberDictionary();
// Reset everything
backingWidth = 0;
totalWidth = 0;
groupInfo.clear();
};
for(; memberIndex < structDecl->members.getCount(); ++memberIndex)
{
const auto& m = structDecl->members[memberIndex];
// We can trivially skip any non-property decls
const auto v = as<PropertyDecl>(m);
if(!v)
{
// If this is a non-bitfield member then finish the current group
if(as<VarDecl>(m))
dispatchSomeBitPackedMembers();
continue;
}
const auto bfm = m->findModifier<BitFieldModifier>();
// If there isn't a bit field modifier, then dispatch the
// current group and continue
if(!bfm)
{
dispatchSomeBitPackedMembers();
continue;
}
// Verify that this makes sense as a bitfield
const auto t = v->type.type->getCanonicalType();
SLANG_ASSERT(t);
const auto b = as<BasicExpressionType>(t);
if(!b)
{
getSink()->diagnose(v->loc, Diagnostics::bitFieldNonIntegral, t);
continue;
}
const auto baseType = b->getBaseType();
const bool isIntegerType = isIntegerBaseType(baseType);
if(!isIntegerType)
{
getSink()->diagnose(v->loc, Diagnostics::bitFieldNonIntegral, t);
continue;
}
// The bit width of this member, and the member type width
const auto thisFieldWidth = bfm->width;
const auto thisFieldTypeWidth = getTypeBitSize(b);
SLANG_ASSERT(thisFieldTypeWidth != 0);
if(thisFieldWidth > thisFieldTypeWidth)
{
getSink()->diagnose(
v->loc,
Diagnostics::bitFieldTooWide,
thisFieldWidth,
t,
thisFieldTypeWidth
);
// Not much we can do with this field, just ignore it
continue;
}
// At this point we're sure that we have a bit field,
// update our bit packing state
// If there's a 0 width type, dispatch the current group
if(thisFieldWidth == 0)
dispatchSomeBitPackedMembers();
// If this member wouldn't fit into the current group, dispatch
// everything so far;
if(totalWidth + thisFieldWidth > std::max(thisFieldTypeWidth, backingWidth))
dispatchSomeBitPackedMembers();
// Add this member to the group,
// Grow the backing width if necessary
backingWidth = std::max(thisFieldTypeWidth, backingWidth);
// Grow the total width
totalWidth += int(thisFieldWidth);
groupInfo.add({memberIndex, int(thisFieldWidth), t, bfm});
}
// If the struct ended with a bitpacked member, then make sure we don't forget the last group
dispatchSomeBitPackedMembers();
}
void SemanticsDeclAttributesVisitor::visitFunctionDeclBase(FunctionDeclBase* decl)
{
// Run checking on attributes that can't be fully checked in header checking stage.
for (auto attr : decl->modifiers)
{
if (auto fwdDerivativeOfAttr = as<ForwardDerivativeOfAttribute>(attr))
checkForwardDerivativeOfAttribute(decl, fwdDerivativeOfAttr);
else if (auto bwdDerivativeOfAttr = as<BackwardDerivativeOfAttribute>(attr))
checkBackwardDerivativeOfAttribute(decl, bwdDerivativeOfAttr);
else if (auto primalOfAttr = as<PrimalSubstituteOfAttribute>(attr))
checkPrimalSubstituteOfAttribute(decl, primalOfAttr);
else if (auto fwdDerivativeAttr = as<ForwardDerivativeAttribute>(attr))
checkDerivativeAttribute(this, decl, fwdDerivativeAttr);
else if (auto bwdDerivativeAttr = as<BackwardDerivativeAttribute>(attr))
checkDerivativeAttribute(this, decl, bwdDerivativeAttr);
else if (auto primalAttr = as<PrimalSubstituteAttribute>(attr))
checkDerivativeAttribute(this, decl, primalAttr);
}
}
static void _propagateRequirement(SemanticsVisitor* visitor, CapabilitySet& resultCaps, SyntaxNode* userNode, SyntaxNode* referencedNode, const CapabilitySet& nodeCaps, SourceLoc referenceLoc)
{
auto referencedDecl = as<Decl>(referencedNode);
// Ignore cyclic references.
if (referencedDecl)
{
if (referencedDecl->checkState.isBeingChecked())
return;
ensureDecl(visitor, referencedDecl, DeclCheckState::CapabilityChecked);
}
if (resultCaps.implies(nodeCaps))
return;
auto oldCaps = resultCaps;
bool isAnyInvalid = resultCaps.isInvalid() || nodeCaps.isInvalid();
resultCaps.join(nodeCaps);
auto decl = as<Decl>(userNode);
if (!isAnyInvalid && resultCaps.isInvalid())
{
// If joining the referenced decl's requirements results an invalid capability set,
// then the decl is using things that require conflicting set of capabilities, and we should diagnose an error.
if (referencedDecl && decl)
{
visitor->getSink()->diagnose(
referenceLoc,
Diagnostics::conflictingCapabilityDueToUseOfDecl,
referencedDecl,
nodeCaps,
decl,
oldCaps);
}
else if (decl)
{
visitor->getSink()->diagnose(
referenceLoc,
Diagnostics::conflictingCapabilityDueToStatement,
nodeCaps,
decl,
oldCaps);
}
else
{
visitor->getSink()->diagnose(
referenceLoc,
Diagnostics::conflictingCapabilityDueToStatementEnclosingFunc,
nodeCaps,
oldCaps);
}
}
if (referencedDecl && decl)
{
for (auto& capSet : nodeCaps.getExpandedAtoms())
{
for (auto atom : capSet.getExpandedAtoms())
{
decl->capabilityRequirementProvenance.addIfNotExists(atom, DeclReferenceWithLoc{ referencedDecl, referenceLoc });
}
}
}
};
CapabilitySet getStatementCapabilityUsage(SemanticsVisitor* visitor, Stmt* stmt);
template<typename ProcessFunc>
struct CapabilityDeclReferenceVisitor
: public SemanticsDeclReferenceVisitor<CapabilityDeclReferenceVisitor<ProcessFunc>>
{
typedef SemanticsDeclReferenceVisitor<CapabilityDeclReferenceVisitor<ProcessFunc>> Base;
const ProcessFunc& handleReferenceFunc;
CapabilityDeclReferenceVisitor(const ProcessFunc& processFunc, SemanticsContext const& outer)
: handleReferenceFunc(processFunc)
, SemanticsDeclReferenceVisitor<CapabilityDeclReferenceVisitor<ProcessFunc>>(outer)
{
}
virtual void processReferencedDecl(Decl* decl) override
{
SourceLoc loc = SourceLoc();
if (Base::sourceLocStack.getCount())
loc = Base::sourceLocStack.getLast();
handleReferenceFunc(decl, decl->inferredCapabilityRequirements, loc);
}
void visitDiscardStmt(DiscardStmt* stmt)
{
handleReferenceFunc(stmt, CapabilitySet(CapabilityName::fragment), stmt->loc);
}
void visitTargetSwitchStmt(TargetSwitchStmt* stmt)
{
CapabilitySet set;
for (auto targetCase : stmt->targetCases)
{
auto targetCap = CapabilitySet(CapabilityName(targetCase->capability));
auto oldCap = targetCap;
auto bodyCap = getStatementCapabilityUsage(this, targetCase->body);
targetCap.join(bodyCap);
if (targetCap.isInvalid())
{
Base::getSink()->diagnose(targetCase->body->loc, Diagnostics::conflictingCapabilityDueToStatement, bodyCap, "target_switch", oldCap);
}
for (auto& conjunction : targetCap.getExpandedAtoms())
set.unionWith(conjunction);
}
set.canonicalize();
handleReferenceFunc(stmt, set, stmt->loc);
}
void visitRequireCapabilityDecl(RequireCapabilityDecl* decl)
{
handleReferenceFunc(decl, decl->inferredCapabilityRequirements, decl->loc);
}
};
template<typename ProcessFunc>
void visitReferencedDecls(SemanticsContext& context, NodeBase* node, SourceLoc initialLoc, const ProcessFunc& func)
{
CapabilityDeclReferenceVisitor<ProcessFunc> visitor(func, context);
visitor.sourceLocStack.add(initialLoc);
if (auto val = as<Val>(node))
visitor.dispatchIfNotNull(val);
if (auto stmt = as<Stmt>(node))
visitor.dispatchIfNotNull(stmt);
if (auto expr = as<Expr>(node))
visitor.dispatchIfNotNull(expr);
if (auto decl = as<Decl>(node))
visitor.dispatchIfNotNull(decl);
}
CapabilitySet getStatementCapabilityUsage(SemanticsVisitor* visitor, Stmt* stmt)
{
if (stmt == nullptr)
return CapabilitySet();
CapabilitySet inferredRequirements;
visitReferencedDecls(*visitor, stmt, stmt->loc, [&](SyntaxNode* node, const CapabilitySet& nodeCaps, SourceLoc refLoc)
{
_propagateRequirement(visitor, inferredRequirements, stmt, node, nodeCaps, refLoc);
});
return inferredRequirements;
}
void SemanticsDeclCapabilityVisitor::checkVarDeclCommon(VarDeclBase* varDecl)
{
visitReferencedDecls(*this, varDecl->type.type, varDecl->loc, [this, varDecl](SyntaxNode* node, const CapabilitySet& nodeCaps, SourceLoc refLoc)
{
_propagateRequirement(this, varDecl->inferredCapabilityRequirements, varDecl, node, nodeCaps, refLoc);
});
visitReferencedDecls(*this, varDecl->initExpr, varDecl->loc, [this, varDecl](SyntaxNode* node, const CapabilitySet& nodeCaps, SourceLoc refLoc)
{
_propagateRequirement(this, varDecl->inferredCapabilityRequirements, varDecl, node, nodeCaps, refLoc);
});
}
CapabilitySet SemanticsDeclCapabilityVisitor::getDeclaredCapabilitySet(Decl* decl)
{
// Merge a decls's declared capability set with all parent declarations.
// For every existing target, we want to join their requirements together.
// If the the parent defines additional targets, we want to add them to the disjunction set.
// For example:
// [require(glsl)] struct Parent { [require(glsl, glsl_ext_1)] [require(spirv)] void foo(); }
// The requirement for `foo` should be glsl+glsl_ext_1 | spirv.
//
CapabilitySet declaredCaps;
for (Decl* parent = decl; parent; parent = getParentDecl(parent))
{
CapabilitySet localDeclaredCaps;
bool shouldBreak = false;
if (!as<AggTypeDeclBase>(parent) || parent->inferredCapabilityRequirements.isEmpty())
{
for (auto decoration : parent->getModifiersOfType<RequireCapabilityAttribute>())
{
for (auto& set : decoration->capabilitySet.getExpandedAtoms())
localDeclaredCaps.unionWith(set);
}
}
else
{
localDeclaredCaps = parent->inferredCapabilityRequirements;
shouldBreak = true;
}
// Merge decl's capability declaration with the parent.
for (auto& localConjunction : localDeclaredCaps.getExpandedAtoms())
{
if (declaredCaps.isIncompatibleWith(localConjunction))
declaredCaps.unionWith(localConjunction);
else
declaredCaps.join(localDeclaredCaps);
}
// If the parent already has inferred capability requirements, we should stop now
// since that already covers transitive parents.
if (shouldBreak)
break;
}
return declaredCaps;
}
void SemanticsDeclCapabilityVisitor::visitAggTypeDeclBase(AggTypeDeclBase* decl)
{
decl->inferredCapabilityRequirements = getDeclaredCapabilitySet(decl);
}
void SemanticsDeclCapabilityVisitor::visitNamespaceDeclBase(NamespaceDeclBase* decl)
{
decl->inferredCapabilityRequirements = getDeclaredCapabilitySet(decl);
}
void SemanticsDeclCapabilityVisitor::visitFunctionDeclBase(FunctionDeclBase* funcDecl)
{
for (auto member : funcDecl->members)
{
ensureDecl(member, DeclCheckState::CapabilityChecked);
_propagateRequirement(this, funcDecl->inferredCapabilityRequirements, funcDecl, member, member->inferredCapabilityRequirements, member->loc);
}
visitReferencedDecls(*this, funcDecl->body, funcDecl->loc, [this, funcDecl](SyntaxNode* node, const CapabilitySet& nodeCaps, SourceLoc refLoc)
{
_propagateRequirement(this, funcDecl->inferredCapabilityRequirements, funcDecl, node, nodeCaps, refLoc);
});
if (!isEffectivelyStatic(funcDecl))
{
auto parentAggTypeDecl = getParentAggTypeDecl(funcDecl);
if (parentAggTypeDecl)
{
ensureDecl(parentAggTypeDecl, DeclCheckState::CapabilityChecked);
_propagateRequirement(this, funcDecl->inferredCapabilityRequirements, funcDecl, parentAggTypeDecl, parentAggTypeDecl->inferredCapabilityRequirements, funcDecl->loc);
}
}
auto declaredCaps = getDeclaredCapabilitySet(funcDecl);
if (!declaredCaps.isEmpty())
{
// If the function is an entrypoint, add the stage to declaredCaps.
if (auto entryPointAttr = funcDecl->findModifier<EntryPointAttribute>())
{
auto stageCaps = CapabilitySet(Profile(entryPointAttr->stage).getCapabilityName());
if (declaredCaps.isIncompatibleWith(stageCaps))
{
getSink()->diagnose(funcDecl->loc, Diagnostics::stageIsInCompatibleWithCapabilityDefinition, funcDecl, stageCaps, declaredCaps);
}
else
{
declaredCaps.join(stageCaps);
}
}
}
auto vis = getDeclVisibility(funcDecl);
if (declaredCaps.isEmpty())
{
// If the user has not declared any capabilities,
// we should diagnose an error if this is a public symbol.
if (vis == DeclVisibility::Public && !funcDecl->inferredCapabilityRequirements.isEmpty())
{
if (!getModuleDecl(funcDecl)->isInLegacyLanguage)
{
if (funcDecl->inferredCapabilityRequirements != getAnyPlatformCapabilitySet())
{
getSink()->diagnose(
funcDecl->loc,
Diagnostics::missingCapabilityRequirementOnPublicDecl,
funcDecl, funcDecl->inferredCapabilityRequirements);
}
}
}
}
else
{
if (vis == DeclVisibility::Public)
{
// For public decls, we need to enforce that the function
// only uses capabilities that it declares.
const CapabilityConjunctionSet* failedAvailableCapabilityConjunction = nullptr;
if (!CapabilitySet::checkCapabilityRequirement(
declaredCaps,
funcDecl->inferredCapabilityRequirements,
failedAvailableCapabilityConjunction))
{
diagnoseUndeclaredCapability(funcDecl, Diagnostics::useOfUndeclaredCapability, failedAvailableCapabilityConjunction);
funcDecl->inferredCapabilityRequirements = declaredCaps;
}
}
else
{
// For internal decls, their inferred capability should be joined
// with the declared capabilities.
funcDecl->inferredCapabilityRequirements.join(declaredCaps);
}
}
}
void SemanticsDeclCapabilityVisitor::visitInheritanceDecl(InheritanceDecl* inheritanceDecl)
{
// Check that the implementation of an interface requirement is not using more capabilities
// than what's declared on the interface method.
if (inheritanceDecl->witnessTable)
{
for (auto& kv : inheritanceDecl->witnessTable->m_requirementDictionary)
{
if (kv.value.getFlavor() != RequirementWitness::Flavor::declRef)
continue;
auto requirementDecl = kv.key;
auto implDecl = kv.value.getDeclRef();
if (!implDecl)
continue;
if (getModuleDecl(implDecl.getDecl())->isInLegacyLanguage)
break;
ensureDecl(requirementDecl, DeclCheckState::CapabilityChecked);
ensureDecl(implDecl.declRefBase, DeclCheckState::CapabilityChecked);
const CapabilityConjunctionSet* failedAvailableCapabilityConjunction = nullptr;
if (!CapabilitySet::checkCapabilityRequirement(
requirementDecl->inferredCapabilityRequirements,
implDecl.getDecl()->inferredCapabilityRequirements,
failedAvailableCapabilityConjunction))
{
diagnoseUndeclaredCapability(implDecl.getDecl(), Diagnostics::useOfUndeclaredCapabilityOfInterfaceRequirement, failedAvailableCapabilityConjunction);
}
}
}
}
DeclVisibility getDeclVisibility(Decl* decl)
{
if (as<GenericTypeParamDecl>(decl) || as<GenericValueParamDecl>(decl) || as<GenericTypeConstraintDecl>(decl))
{
auto genericDecl = as<GenericDecl>(decl->parentDecl);
if (!genericDecl)
return DeclVisibility::Default;
if (genericDecl->inner)
return getDeclVisibility(genericDecl->inner);
return DeclVisibility::Default;
}
if (auto genericDecl = as<GenericDecl>(decl))
decl = genericDecl->inner;
for (; decl; decl = getParentDecl(decl))
{
if (as<AccessorDecl>(decl))
continue;
if (as<EnumCaseDecl>(decl))
continue;
break;
}
if (!decl)
return DeclVisibility::Public;
for (auto modifier : decl->modifiers)
{
if (as<PublicModifier>(modifier))
return DeclVisibility::Public;
else if (as<InternalModifier>(modifier))
return DeclVisibility::Internal;
else if (as<PrivateModifier>(modifier))
return DeclVisibility::Private;
}
// Interface members will always have the same visibility as the interface itself.
if (auto interfaceDecl = findParentInterfaceDecl(decl))
{
return getDeclVisibility(interfaceDecl);
}
auto defaultVis = DeclVisibility::Default;
if (auto parentModule = getModuleDecl(decl))
defaultVis = parentModule->isInLegacyLanguage ? DeclVisibility::Public : DeclVisibility::Internal;
// Members of other agg type decls will have their default visibility capped to the parents'.
if (as<NamespaceDecl>(decl))
{
return DeclVisibility::Public;
}
return defaultVis;
}
void diagnoseCapabilityProvenance(DiagnosticSink* sink, Decl* decl, CapabilityAtom missingAtom)
{
HashSet<Decl*> printedDecls;
auto thisModule = getModuleDecl(decl);
Decl* declToPrint = decl;
while (declToPrint)
{
printedDecls.add(declToPrint);
if (auto provenance = declToPrint->capabilityRequirementProvenance.tryGetValue(missingAtom))
{
sink->diagnose(provenance->referenceLoc, Diagnostics::seeUsingOf, provenance->referencedDecl);
declToPrint = provenance->referencedDecl;
if (printedDecls.contains(declToPrint))
break;
if (declToPrint->findModifier<RequireCapabilityAttribute>())
break;
auto moduleDecl = getModuleDecl(declToPrint);
if (thisModule != moduleDecl)
break;
if (moduleDecl && moduleDecl->isInLegacyLanguage)
continue;
if (getDeclVisibility(declToPrint) == DeclVisibility::Public)
break;
}
else
{
break;
}
}
if (declToPrint)
{
sink->diagnose(declToPrint->loc, Diagnostics::seeDefinitionOf, declToPrint);
}
}
// Print diagnostics tracing which referenced decls are not compatible with the given atom.
void diagnoseIncompatibleAtomProvenance(SemanticsVisitor* visitor, DiagnosticSink* sink, Decl* decl, CapabilityAtom incompatibleAtom, int traceLevels = 10)
{
Decl* refDecl = nullptr;
SourceLoc loc;
HashSet<Decl*> printedDecls;
while (traceLevels > 0)
{
refDecl = nullptr;
visitReferencedDecls(*visitor, decl, decl->loc, [&](SyntaxNode* node, const CapabilitySet& nodeCaps, SourceLoc refLoc)
{
if (nodeCaps.isIncompatibleWith(incompatibleAtom))
{
if (auto referencedDecl = as<Decl>(node))
{
refDecl = referencedDecl;
loc = refLoc;
}
else
sink->diagnose(refLoc, Diagnostics::seeDefinitionOf, "statement");
}
});
if (!refDecl)
break;
if (printedDecls.add(refDecl))
{
sink->diagnose(loc, Diagnostics::seeUsingOf, refDecl);
decl = refDecl;
}
else
{
break;
}
traceLevels--;
}
}
void SemanticsDeclCapabilityVisitor::diagnoseUndeclaredCapability(Decl* decl, const DiagnosticInfo& diagnosticInfo, const CapabilityConjunctionSet* failedAvailableSet)
{
if (decl->inferredCapabilityRequirements.getExpandedAtoms().getCount() == 0)
return;
// There are two causes for why type checking failed on failedAvailableSet.
// The first scenario is that failedAvailableSet defines a set of capabilities on a
// compilation target (e.g. hlsl) that isn't defined by some callees, for example, if we have
// a function:
// [require(hlsl)] // <-- failedAvailableSet
// [require(cpp)]
// void caller()
// {
// printf(); // assume this is defined for (cpp | cuda).
// }
// In this case we should diagnose error reporting printf isn't defined on a required target.
//
// The second scenario is when the callee is using a capability that is not provided by the requirement.
// For example:
// [require(hlsl,b,c)]
// void caller()
// {
// useD(); // require capability (hlsl,d)
// }
// In this case we should report that useD() is using a capability that is not declared by caller.
//
// Now, we detect if we are case 1.
if (decl->inferredCapabilityRequirements.isIncompatibleWith(*failedAvailableSet))
{
// Find the most derived atom that is leading to the incompatiblity.
for (Index i = failedAvailableSet->getExpandedAtoms().getCount() - 1; i >= 0; i--)
{
auto atom = failedAvailableSet->getExpandedAtoms()[i];
if (!isDirectChildOfAbstractAtom(atom))
continue;
if (decl->inferredCapabilityRequirements.isIncompatibleWith(atom))
{
getSink()->diagnose(decl->loc, Diagnostics::declHasDependenciesNotDefinedOnTarget, decl, atom);
diagnoseIncompatibleAtomProvenance(this, getSink(), decl, atom);
return;
}
}
return;
}
// If we reach here, we are case 2.
CapabilityConjunctionSet* matchingRequirement = &decl->inferredCapabilityRequirements.getExpandedAtoms().getFirst();
CapabilityAtom missingAtom = matchingRequirement->getExpandedAtoms().getFirst();
if (missingAtom == CapabilityAtom::Invalid)
return;
if (failedAvailableSet)
{
Int maxIntersectionCount = 0;
for (auto& usedSet : decl->inferredCapabilityRequirements.getExpandedAtoms())
{
auto intersection = usedSet.countIntersectionWith(*failedAvailableSet);
if (intersection > maxIntersectionCount)
{
matchingRequirement = &usedSet;
maxIntersectionCount = intersection;
}
}
Index pos = 0;
for (Index i = 0; i < matchingRequirement->getExpandedAtoms().getCount(); i++)
{
auto atom = matchingRequirement->getExpandedAtoms()[i];
while (pos < failedAvailableSet->getExpandedAtoms().getCount())
{
if (failedAvailableSet->getExpandedAtoms()[pos] < atom)
pos++;
else
break;
}
if (pos >= failedAvailableSet->getExpandedAtoms().getCount() ||
failedAvailableSet->getExpandedAtoms()[pos] != atom)
{
missingAtom = atom;
break;
}
}
// Select the most derived atom of `missingAtom`.
for (Index i = matchingRequirement->getExpandedAtoms().getCount() - 1; i >= 0 ; i--)
{
auto atom = matchingRequirement->getExpandedAtoms()[i];
if (CapabilityConjunctionSet(atom).implies(missingAtom))
{
missingAtom = atom;
break;
}
}
}
getSink()->diagnose(decl->loc, diagnosticInfo, decl, missingAtom);
// Print provenances.
diagnoseCapabilityProvenance(getSink(), decl, missingAtom);
}
}
