Rename some symbols related to pointers types (#8592)

Note that while this change touched a large numer of files, there are no
changes to functionality being made here. The only things being done are
renaming various symbols and, in a few cases, updating or adding
comments for consistency with the new names.

The core of the naming changes are:

* Most things named to refer to `OutType` (e.g., `IROutType`,
`IRBuilder::getOutType()`, etc.) have been consistently renamed to refer
to `OutParamType`, to emphasize that the relevant AST/IR node types are
only intended for use to represent `out` parameters.

* The same change as described above for `OutType` is also made for
`RefType`, which becomes `RefParamType` in most cases. One mess that
this exposes is the way that the `ExplicitRef<T>` type in the core
module currently lowers to `IRRefParamType`. This change sticks to the
rule of not making functional changes, so that mess is left as-is for
now.

* Names referring to `InOutType` have been changed to instead refer to
`BorrowInOutType`. The intention with this naming change is to emphasize
that the Slang rules for `inout` are semantically those of a borrow (or
at least our interpretation of what a borrow means).

* Names referring to `ConstRefType` have been changed to instead refer
to `BorrowInType`. This change starts work on clarifying that the
existing `__constref` modifier was never intended to be a read-only
analogue of `__ref`, and instead is the input-only analogue of `inout`.

* The `ParameterDirection` enum type has been changed to
`ParamPassingMode`, to reflect the fact that the concept of "direction"
fails to capture what is actually being encoded, particularly once we
have modes beyond simple `in`/`out`/`inout`.

While this change does not alter behavior in any case (the user-exposed
Slang language is unchanged), it is intended to set up subsequence
changes that will work to make the handling of these types in the
compiler more nuanced and correct. Breaking this part of the change out
separately is primarily motivated by a desire to minimize the effort for
reviewers.

---------

Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>

71 files changed, 537 insertions, 448 deletions

diff --git a/external/spirv-tools b/external/spirv-tools
-Subproject f932fc23e2f84c8affbca4b2761d1da7dd4e0cc
+Subproject 7f2d9ee926f98fc77a3ed1e1e0f113b8c9c4945
diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index 54e693117..5ffab1f9c 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -1526,8 +1526,12 @@ extension uintptr_t : IRangedValue
 
 //@hidden:
 
+// TODO(tfoley): This should really map over to `kIROp_PtrType`,
+// but is currently still mapping to the IR opcode used for `ref`
+// parameters.
+//
 __magic_type(ExplicitRefType)
-__intrinsic_type($(kIROp_RefType))
+__intrinsic_type($(kIROp_RefParamType))
 struct Ref<
     T, 
     Access access = Access::ReadWrite, 
@@ -1535,23 +1539,23 @@ struct Ref<
 {};
 
 __magic_type(OutParamType)
-__intrinsic_type($(kIROp_OutType))
+__intrinsic_type($(kIROp_OutParamType))
 struct OutParam<T>
 {};
 
-__magic_type(InOutParamType)
-__intrinsic_type($(kIROp_InOutType))
-struct InOutParam<T>
+__magic_type(BorrowInOutParamType)
+__intrinsic_type($(kIROp_BorrowInOutParamType))
+struct BorrowInOutParam<T>
 {};
 
 __magic_type(RefParamType)
-__intrinsic_type($(kIROp_RefType))
+__intrinsic_type($(kIROp_RefParamType))
 struct RefParam<T>
 {};
 
-__magic_type(ConstRefParamType)
-__intrinsic_type($(kIROp_ConstRefType))
-struct ConstRefParam<T>
+__magic_type(BorrowInParamType)
+__intrinsic_type($(kIROp_BorrowInParamType))
+struct BorrowInParam<T>
 {};
 
 // __Addr<T> is AddressSpace::Generic since Slang will specalize & validate the address-space
diff --git a/source/slang/slang-ast-builder.cpp b/source/slang/slang-ast-builder.cpp
index be71fc334..4304bc7c7 100644
--- a/source/slang/slang-ast-builder.cpp
+++ b/source/slang/slang-ast-builder.cpp
@@ -510,14 +510,14 @@ Type* ASTBuilder::getScalarLayoutType()
 }
 
 // Construct the type `Out<valueType>`
-OutType* ASTBuilder::getOutType(Type* valueType)
+OutType* ASTBuilder::getOutParamType(Type* valueType)
 {
     return dynamicCast<OutType>(getPtrType(valueType, "OutParamType"));
 }
 
-InOutType* ASTBuilder::getInOutType(Type* valueType)
+BorrowInOutParamType* ASTBuilder::getBorrowInOutParamType(Type* valueType)
 {
-    return dynamicCast<InOutType>(getPtrType(valueType, "InOutParamType"));
+    return dynamicCast<BorrowInOutParamType>(getPtrType(valueType, "BorrowInOutParamType"));
 }
 
 RefParamType* ASTBuilder::getRefParamType(Type* valueType)
@@ -525,9 +525,9 @@ RefParamType* ASTBuilder::getRefParamType(Type* valueType)
     return dynamicCast<RefParamType>(getPtrType(valueType, "RefParamType"));
 }
 
-ConstRefParamType* ASTBuilder::getConstRefParamType(Type* valueType)
+BorrowInParamType* ASTBuilder::getConstRefParamType(Type* valueType)
 {
-    return dynamicCast<ConstRefParamType>(getPtrType(valueType, "ConstRefParamType"));
+    return dynamicCast<BorrowInParamType>(getPtrType(valueType, "BorrowInParamType"));
 }
 
 ExplicitRefType* ASTBuilder::getExplicitRefType(Type* valueType)
diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h
index 9386180c8..f4abd4d12 100644
--- a/source/slang/slang-ast-builder.h
+++ b/source/slang/slang-ast-builder.h
@@ -537,16 +537,16 @@ public:
     PtrType* getPtrType(Type* valueType, Val* accessQualifier, Val* addrSpace);
 
     // Construct the type `OutParam<valueType>`
-    OutParamType* getOutType(Type* valueType);
+    OutParamType* getOutParamType(Type* valueType);
 
     // Construct the type `InOutParam<valueType>`
-    InOutParamType* getInOutType(Type* valueType);
+    BorrowInOutParamType* getBorrowInOutParamType(Type* valueType);
 
     // Construct the type `RefParam<valueType>`
     RefParamType* getRefParamType(Type* valueType);
 
-    // Construct the type `ConstRefParam<valueType>`
-    ConstRefParamType* getConstRefParamType(Type* valueType);
+    // Construct the type `ImmutableBorrowParam<valueType>`
+    BorrowInParamType* getConstRefParamType(Type* valueType);
 
     // Construct the type `Ref<valueType>`
     ExplicitRefType* getExplicitRefType(Type* valueType);
diff --git a/source/slang/slang-ast-modifier.h b/source/slang/slang-ast-modifier.h
index 5793167af..80bb827ff 100644
--- a/source/slang/slang-ast-modifier.h
+++ b/source/slang/slang-ast-modifier.h
@@ -339,16 +339,16 @@ class InOutModifier : public OutModifier
 };
 
 
-// `__ref` modifier for by-reference parameter passing
+// `ref` modifier for by-reference parameter passing
 FIDDLE()
 class RefModifier : public Modifier
 {
     FIDDLE(...)
 };
 
-// `__ref` modifier for by-reference parameter passing
+// `borrow` modifier for borrow parameter passing
 FIDDLE()
-class ConstRefModifier : public Modifier
+class BorrowModifier : public Modifier
 {
     FIDDLE(...)
 };
diff --git a/source/slang/slang-ast-support-types.cpp b/source/slang/slang-ast-support-types.cpp
index 9d9fdb7da..4054d8dc4 100644
--- a/source/slang/slang-ast-support-types.cpp
+++ b/source/slang/slang-ast-support-types.cpp
@@ -88,23 +88,23 @@ UnownedStringSlice getHigherOrderOperatorName(HigherOrderInvokeExpr* expr)
     return UnownedStringSlice();
 }
 
-void printDiagnosticArg(StringBuilder& sb, ParameterDirection direction)
+void printDiagnosticArg(StringBuilder& sb, ParamPassingMode direction)
 {
     switch (direction)
     {
-    case kParameterDirection_In:
+    case ParamPassingMode::In:
         sb << "in";
         break;
-    case kParameterDirection_Out:
+    case ParamPassingMode::Out:
         sb << "out";
         break;
-    case kParameterDirection_Ref:
+    case ParamPassingMode::Ref:
         sb << "ref";
         break;
-    case kParameterDirection_InOut:
+    case ParamPassingMode::BorrowInOut:
         sb << "inout";
         break;
-    case kParameterDirection_ConstRef:
+    case ParamPassingMode::BorrowIn:
         sb << "constref";
         break;
     default:
diff --git a/source/slang/slang-ast-support-types.h b/source/slang/slang-ast-support-types.h
index b69c76307..9dd481acb 100644
--- a/source/slang/slang-ast-support-types.h
+++ b/source/slang/slang-ast-support-types.h
@@ -1686,16 +1686,96 @@ FIDDLE() namespace Slang
     };
 
     /// Represents the "direction" that a parameter is being passed (e.g., `in` or `out`
-    enum ParameterDirection
+    enum class ParamPassingMode
     {
-        kParameterDirection_In,       ///< Copy in
-        kParameterDirection_Out,      ///< Copy out
-        kParameterDirection_InOut,    ///< Copy in, copy out
-        kParameterDirection_Ref,      ///< By-reference
-        kParameterDirection_ConstRef, ///< By-const-reference
+        /// Pass a value as input.
+        ///
+        /// Indicated by using the `in` modifier on a parameter,
+        /// or simply using no modifier (on a parameter of
+        /// copyable type). This is the default mode.
+        ///
+        /// Must (almost by definition) be passed a copy
+        /// of the argument.
+        ///
+        ///
+        In,
+
+        /// Pass a reference to a memory location, to be used for output.
+        ///
+        /// Indicated by using the `out` modifier on a parameter
+        /// (while not also using `in`).
+        ///
+        /// May semantically be implemented by directly passing a
+        /// reference to the argument, or a reference to a temporary
+        /// that is moved out of after the call.
+        ///
+        /// Storage at the passed-in address should be unintialized
+        /// on input, and will be must be initialized by the callee
+        /// on any normal return path. On an error return, the storage
+        /// must be uninitialized.
+        ///
+        Out,
+
+        /// Pass a reference to a borrowed immutable value.
+        ///
+        /// Indicated by using the `borrow` modifier on a parameter,
+        /// or the combination of `borrow` and `in` (while not also
+        /// using `out`).
+        ///
+        /// May semantically be implemented by directly passing a
+        /// reference to the argument, or a reference to a temporary
+        /// that is moved/copied into before the call.
+        ///
+        /// Storage at the passed-in address must be guaranteed (by
+        /// the caller) to be immutable for the duration of the call.
+        ///
+        BorrowIn,
+
+        /// Pass a reference to a borrowed mutable value.
+        ///
+        /// Indicated by using the `inout` modifier on a parameter,
+        /// or the combination of `in` and `out`; may also be combined
+        /// with `borrow` to make the semantics more clear.
+        ///
+        /// May semantically be implemented by directly passing a
+        /// reference to the argument, or a reference to a temporary
+        /// that is moved/copied into before the call, and then
+        /// moved/copied out of after the call.
+        ///
+        /// Storage at the passed-in address must be guaranteed (by
+        /// the caller) to not be be accessed (including both reads
+        /// and writes) via any other potentially-aliasing access path.
+        /// Put another way, the callee has exclusive access to the
+        /// memory location for the duration of the call.
+        ///
+        BorrowInOut,
+
+        /// Pass a reference to a mutable memory location.
+        ///
+        /// Indicated by using the `ref` modifier on a parmater
+        /// (without also using the `readonly` or `writeonly` modifiers).
+        ///
+        /// Must be implemented by directly passing a reference to
+        /// the memory location of the argument. It is an error if
+        /// an argument resolves to a storage location that is not
+        /// a memory location (and cannot be turned into a memory
+        /// location via, e.g., a `ref` accessor).
+        ///
+        /// The memory location at the passed-in address may be
+        /// accessed (for reads, writes, atomics, etc.) during the
+        /// duration of the call, through access paths that alias
+        /// the parameter. The callee does not have a guarantee
+        /// of exclusivity of access to the memory location, and
+        /// must take appropriate precautions to ensure consistency,
+        /// coherency, and synchronization of access.
+        ///
+        /// This parameter-passing mode is more-or-less just syntactic
+        /// sugar for a parameter of an explicit pointer type (`Ptr<T>`).
+        ///
+        Ref,
     };
 
-    void printDiagnosticArg(StringBuilder & sb, ParameterDirection direction);
+    void printDiagnosticArg(StringBuilder & sb, ParamPassingMode direction);
 
     /// The kind of a builtin interface requirement that can be automatically synthesized.
     enum class BuiltinRequirementKind
diff --git a/source/slang/slang-ast-type.cpp b/source/slang/slang-ast-type.cpp
index 1af81a88f..a3b4b91f6 100644
--- a/source/slang/slang-ast-type.cpp
+++ b/source/slang/slang-ast-type.cpp
@@ -544,7 +544,7 @@ void OutParamType::_toTextOverride(StringBuilder& out)
     out << toSlice("out ") << getValueType();
 }
 
-void InOutParamType::_toTextOverride(StringBuilder& out)
+void BorrowInOutParamType::_toTextOverride(StringBuilder& out)
 {
     out << toSlice("inout ") << getValueType();
 }
@@ -554,7 +554,7 @@ void RefParamType::_toTextOverride(StringBuilder& out)
     out << toSlice("ref ") << getValueType();
 }
 
-void ConstRefParamType::_toTextOverride(StringBuilder& out)
+void BorrowInParamType::_toTextOverride(StringBuilder& out)
 {
     out << toSlice("borrow ") << getValueType();
 }
@@ -580,31 +580,31 @@ Type* NamedExpressionType::_createCanonicalTypeOverride()
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! FuncType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-ParameterDirection getParamPassingModeFromPossiblyWrappedParamType(Type* paramType)
+ParamPassingMode getParamPassingModeFromPossiblyWrappedParamType(Type* paramType)
 {
     if (as<RefParamType>(paramType))
     {
-        return kParameterDirection_Ref;
+        return ParamPassingMode::Ref;
     }
-    else if (as<ConstRefParamType>(paramType))
+    else if (as<BorrowInParamType>(paramType))
     {
-        return kParameterDirection_ConstRef;
+        return ParamPassingMode::BorrowIn;
     }
-    else if (as<InOutType>(paramType))
+    else if (as<BorrowInOutParamType>(paramType))
     {
-        return kParameterDirection_InOut;
+        return ParamPassingMode::BorrowInOut;
     }
     else if (as<OutType>(paramType))
     {
-        return kParameterDirection_Out;
+        return ParamPassingMode::Out;
     }
     else
     {
-        return kParameterDirection_In;
+        return ParamPassingMode::In;
     }
 }
 
-ParameterDirection FuncType::getParamDirection(Index index)
+ParamPassingMode FuncType::getParamDirection(Index index)
 {
     auto paramType = getParamTypeWithDirectionWrapper(index);
     return getParamPassingModeFromPossiblyWrappedParamType(paramType);
@@ -613,7 +613,7 @@ ParameterDirection FuncType::getParamDirection(Index index)
 Type* FuncType::getParamValueType(Index index)
 {
     auto paramType = getParamTypeWithDirectionWrapper(index);
-    if (auto wrappedParamType = as<ParamDirectionType>(paramType))
+    if (auto wrappedParamType = as<ParamPassingModeType>(paramType))
         return wrappedParamType->getValueType();
     return paramType;
 }
@@ -1402,10 +1402,10 @@ Val* TextureTypeBase::getFormat()
 
 Type* removeParamDirType(Type* type)
 {
-    for (auto paramDirType = as<ParamDirectionType>(type); paramDirType;)
+    for (auto paramDirType = as<ParamPassingModeType>(type); paramDirType;)
     {
         type = paramDirType->getValueType();
-        paramDirType = as<ParamDirectionType>(type);
+        paramDirType = as<ParamPassingModeType>(type);
     }
     return type;
 }
diff --git a/source/slang/slang-ast-type.h b/source/slang/slang-ast-type.h
index 26d86fc7f..3df34e768 100644
--- a/source/slang/slang-ast-type.h
+++ b/source/slang/slang-ast-type.h
@@ -713,14 +713,8 @@ class PtrType : public PtrTypeBase
 
 /// A pointer-like type used to represent a parameter-passing mode.
 ///
-/// Historically the codebase has referredd to different parameter-passing
-/// modes as parameter "directions," because they initially included
-/// only `in`, `out`, and `inout`. The name is confusing when applied
-/// to things like `ref` parameters, but we haven't had time to rename
-/// everything yet.
-///
 FIDDLE()
-class ParamDirectionType : public PtrTypeBase
+class ParamPassingModeType : public PtrTypeBase
 {
     FIDDLE(...)
 };
@@ -729,13 +723,12 @@ class ParamDirectionType : public PtrTypeBase
 // logical pointer that is passed for an `out`
 // or `in out` parameter
 FIDDLE(abstract)
-class OutParamTypeBase : public ParamDirectionType
+class OutParamTypeBase : public ParamPassingModeType
 {
     FIDDLE(...)
 };
-using OutTypeBase = OutParamTypeBase;
 
-// The type for an `out` parameter, e.g., `out T`
+// The type for an output parameter, e.g., `out T`
 FIDDLE()
 class OutParamType : public OutParamTypeBase
 {
@@ -744,24 +737,23 @@ class OutParamType : public OutParamTypeBase
 };
 using OutType = OutParamType;
 
-// The type for an `in out` parameter, e.g., `in out T`
+// The type for a mutable borrow input/output parameter, e.g., `in out T`
 FIDDLE()
-class InOutParamType : public OutParamTypeBase
+class BorrowInOutParamType : public OutParamTypeBase
 {
     FIDDLE(...)
     void _toTextOverride(StringBuilder& out);
 };
-using InOutType = InOutParamType;
 
-// The type for an `ref` parameter, e.g., `ref T`
+// The type for a by-reference parameter, e.g., `ref T`
 FIDDLE()
-class RefParamType : public ParamDirectionType
+class RefParamType : public ParamPassingModeType
 {
     FIDDLE(...)
     void _toTextOverride(StringBuilder& out);
 };
 
-/// The type for a `constref` parameter, e.g., `constref T`
+/// The type for a immutable borrow input parameter, e.g., `borrow T`
 ///
 /// Note that, despite the modifier currently used to represent
 /// this case in code, this is *not* comparable to the `ref`
@@ -769,7 +761,7 @@ class RefParamType : public ParamDirectionType
 /// equivalent of `inout`.
 ///
 FIDDLE()
-class ConstRefParamType : public ParamDirectionType
+class BorrowInParamType : public ParamPassingModeType
 {
     FIDDLE(...)
     void _toTextOverride(StringBuilder& out);
@@ -880,14 +872,14 @@ class FuncType : public Type
 
     /// Get the parameter-passing mode of one of the function's parameters, by index.
     ///
-    ParameterDirection getParamDirection(Index index);
+    ParamPassingMode getParamDirection(Index index);
 
     /// Combined information on the type and parameter-passing mode of a parameter.
     ///
     struct ParamInfo
     {
         /// The parameter-passing mode used for the parameter.
-        ParameterDirection direction = kParameterDirection_In;
+        ParamPassingMode direction = ParamPassingMode::In;
 
         /// The user-perceived type of the parameter.
         Type* type = nullptr;
diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp
index 2afd05df2..6a4e3668f 100644
--- a/source/slang/slang-check-decl.cpp
+++ b/source/slang/slang-check-decl.cpp
@@ -5202,13 +5202,13 @@ void SemanticsVisitor::addRequiredParamsToSynthesizedDecl(
             }
             else if (
                 as<InOutModifier>(modifier) || as<OutModifier>(modifier) ||
-                as<ConstRefModifier>(modifier) || as<RefModifier>(modifier))
+                as<BorrowModifier>(modifier) || as<RefModifier>(modifier))
             {
                 auto clonedModifier =
                     (Modifier*)m_astBuilder->createByNodeType(modifier->astNodeType);
                 clonedModifier->keywordName = modifier->keywordName;
                 addModifier(synParamDecl, clonedModifier);
-                if (as<ConstRefModifier>(modifier))
+                if (as<BorrowModifier>(modifier))
                     paramType.isLeftValue = false;
             }
         }
@@ -5361,15 +5361,15 @@ static bool isWrapperTypeDecl(Decl* decl)
 // Is it allowed to have an interface method parameter whose direction is `reqDir`, and an
 // implementing method parameter whose direction is `implDir`?
 //
-static bool matchParamDirection(ParameterDirection implDir, ParameterDirection reqDir)
+static bool matchParamDirection(ParamPassingMode implDir, ParamPassingMode reqDir)
 {
     // If the parameter directions match exactly, then we are good.
     if (implDir == reqDir)
         return true;
     // Otherwise, we only allow the cases where reqDir is `InOut` and implDir is `In` or `Out`.
-    if (implDir == kParameterDirection_In && reqDir == kParameterDirection_InOut)
+    if (implDir == ParamPassingMode::In && reqDir == ParamPassingMode::BorrowInOut)
         return true;
-    if (implDir == kParameterDirection_Out && reqDir == kParameterDirection_InOut)
+    if (implDir == ParamPassingMode::Out && reqDir == ParamPassingMode::BorrowInOut)
         return true;
     return false;
 }
@@ -9440,8 +9440,8 @@ bool SemanticsVisitor::doFunctionSignaturesMatch(DeclRef<FuncDecl> fst, DeclRef<
 
         // If one parameter is `constref` and the other isn't, then they don't match.
         //
-        if (fstParam.getDecl()->hasModifier<ConstRefModifier>() !=
-            sndParam.getDecl()->hasModifier<ConstRefModifier>())
+        if (fstParam.getDecl()->hasModifier<BorrowModifier>() !=
+            sndParam.getDecl()->hasModifier<BorrowModifier>())
             return false;
     }
 
@@ -9962,7 +9962,7 @@ void SemanticsDeclHeaderVisitor::visitParamDecl(ParamDecl* paramDecl)
                     isMutable = true;
                     continue;
                 }
-                if (as<RefModifier>(modifier) || as<ConstRefModifier>(modifier))
+                if (as<RefModifier>(modifier) || as<BorrowModifier>(modifier))
                 {
                     hasRefModifier = true;
                 }
@@ -9973,7 +9973,7 @@ void SemanticsDeclHeaderVisitor::visitParamDecl(ParamDecl* paramDecl)
                 if (isMutable)
                     newModifiers.add(this->getASTBuilder()->create<RefModifier>());
                 else
-                    newModifiers.add(this->getASTBuilder()->create<ConstRefModifier>());
+                    newModifiers.add(this->getASTBuilder()->create<BorrowModifier>());
             }
             paramDecl->modifiers.first = newModifiers.getFirst();
             for (Index i = 0; i < newModifiers.getCount(); i++)
@@ -9992,7 +9992,7 @@ void SemanticsDeclHeaderVisitor::visitParamDecl(ParamDecl* paramDecl)
         for (auto modifier : paramDecl->modifiers)
         {
             if (as<OutModifier>(modifier) || as<InOutModifier>(modifier) ||
-                as<RefModifier>(modifier) || as<ConstRefModifier>(modifier))
+                as<RefModifier>(modifier) || as<BorrowModifier>(modifier))
             {
                 getSink()->diagnose(modifier, Diagnostics::parameterPackMustBeConst);
             }
@@ -10534,17 +10534,17 @@ void SemanticsDeclHeaderVisitor::setFuncTypeIntoRequirementDecl(
         param->type.type = paramType;
         switch (paramDir)
         {
-        case ParameterDirection::kParameterDirection_InOut:
+        case ParamPassingMode::BorrowInOut:
             addModifier(param, m_astBuilder->create<InOutModifier>());
             break;
-        case ParameterDirection::kParameterDirection_Out:
+        case ParamPassingMode::Out:
             addModifier(param, m_astBuilder->create<OutModifier>());
             break;
-        case ParameterDirection::kParameterDirection_Ref:
+        case ParamPassingMode::Ref:
             addModifier(param, m_astBuilder->create<RefModifier>());
             break;
-        case ParameterDirection::kParameterDirection_ConstRef:
-            addModifier(param, m_astBuilder->create<ConstRefModifier>());
+        case ParamPassingMode::BorrowIn:
+            addModifier(param, m_astBuilder->create<BorrowModifier>());
             break;
         default:
             break;
@@ -10657,11 +10657,11 @@ void SemanticsDeclHeaderVisitor::checkDifferentiableCallableCommon(CallableDecl*
             }
             if (!paramDecl->hasModifier<NoDiffModifier>())
             {
-                if (auto modifier = paramDecl->findModifier<ConstRefModifier>())
+                if (auto modifier = paramDecl->findModifier<BorrowModifier>())
                 {
                     getSink()->diagnose(
                         modifier,
-                        Diagnostics::cannotUseConstRefOnDifferentiableParameter);
+                        Diagnostics::cannotUseBorrowInOnDifferentiableParameter);
                 }
             }
         }
@@ -12946,10 +12946,10 @@ Type* getTypeForThisExpr(SemanticsVisitor* visitor, DeclRef<FunctionDeclBase> fu
 struct ArgsWithDirectionInfo
 {
     List<Expr*> args;
-    List<ParameterDirection> directions;
+    List<ParamPassingMode> directions;
 
     Expr* thisArg;
-    ParameterDirection thisArgDirection;
+    ParamPassingMode thisArgDirection;
 };
 
 template<typename TDerivativeAttr>
@@ -12958,9 +12958,9 @@ void checkDerivativeAttributeImpl(
     Decl* funcDecl,
     TDerivativeAttr* attr,
     const List<Expr*>& imaginaryArguments,
-    const List<ParameterDirection>& expectedParamDirections,
+    const List<ParamPassingMode>& expectedParamDirections,
     Expr* expectedThisArg,
-    ParameterDirection expectedThisArgDirection)
+    ParamPassingMode expectedThisArgDirection)
 {
     if (isInterfaceRequirement(funcDecl))
     {
@@ -13055,20 +13055,20 @@ void checkDerivativeAttributeImpl(
     }
 
     // If left value is true, then convert the
-    // inner type to an InOutType.
+    // inner type to an BorrowInOutParamType.
     //
     auto qualTypeToString = [&](QualType qualType) -> String
     {
         Type* type = qualType.type;
         if (qualType.isLeftValue)
         {
-            type = ctx.getASTBuilder()->getInOutType(type);
+            type = ctx.getASTBuilder()->getBorrowInOutParamType(type);
         }
         return type->toString();
     };
 
     List<Expr*> argList = imaginaryArguments;
-    List<ParameterDirection> paramDirections = expectedParamDirections;
+    List<ParamPassingMode> paramDirections = expectedParamDirections;
     bool expectStaticFunc = false;
 
     if (expectedThisArg)
@@ -13275,7 +13275,7 @@ ArgsWithDirectionInfo getImaginaryArgsToFunc(
     SourceLoc loc)
 {
     List<Expr*> imaginaryArguments;
-    List<ParameterDirection> directions;
+    List<ParamPassingMode> directions;
     for (auto param : func->getParameters())
     {
         auto arg = astBuilder->create<VarExpr>();
@@ -13286,7 +13286,7 @@ ArgsWithDirectionInfo getImaginaryArgsToFunc(
         imaginaryArguments.add(arg);
         directions.add(getParameterDirection(param));
     }
-    return {imaginaryArguments, directions, nullptr, ParameterDirection::kParameterDirection_In};
+    return {imaginaryArguments, directions, nullptr, ParamPassingMode::In};
 }
 
 ArgsWithDirectionInfo getImaginaryArgsToForwardDerivative(
@@ -13314,9 +13314,9 @@ ArgsWithDirectionInfo getImaginaryArgsToForwardDerivative(
         }
     }
 
-    ParameterDirection thisTypeDirection = (thisArgExpr && !thisArgExpr->type.isLeftValue)
-                                               ? ParameterDirection::kParameterDirection_In
-                                               : ParameterDirection::kParameterDirection_InOut;
+    ParamPassingMode thisTypeDirection = (thisArgExpr && !thisArgExpr->type.isLeftValue)
+                                             ? ParamPassingMode::In
+                                             : ParamPassingMode::BorrowInOut;
 
     List<Expr*> imaginaryArguments;
     for (auto param : originalFuncDecl->getParameters())
@@ -13337,7 +13337,7 @@ ArgsWithDirectionInfo getImaginaryArgsToForwardDerivative(
     }
 
     // Copy parameter directions as is.
-    List<ParameterDirection> expectedParamDirections;
+    List<ParamPassingMode> expectedParamDirections;
     for (auto param : originalFuncDecl->getParameters())
     {
         expectedParamDirections.add(getParameterDirection(param));
@@ -13375,12 +13375,12 @@ ArgsWithDirectionInfo getImaginaryArgsToBackwardDerivative(
         }
     }
 
-    ParameterDirection thisTypeDirection = (thisArgExpr && !thisArgExpr->type.isLeftValue)
-                                               ? ParameterDirection::kParameterDirection_In
-                                               : ParameterDirection::kParameterDirection_InOut;
+    ParamPassingMode thisTypeDirection = (thisArgExpr && !thisArgExpr->type.isLeftValue)
+                                             ? ParamPassingMode::In
+                                             : ParamPassingMode::BorrowInOut;
 
     List<Expr*> imaginaryArguments;
-    List<ParameterDirection> expectedParamDirections;
+    List<ParamPassingMode> expectedParamDirections;
 
     auto isOutParam = [&](ParamDecl* param)
     {
@@ -13397,7 +13397,7 @@ ArgsWithDirectionInfo getImaginaryArgsToBackwardDerivative(
         arg->type.type = param->getType();
         arg->loc = loc;
 
-        ParameterDirection direction = getParameterDirection(param);
+        ParamPassingMode direction = getParameterDirection(param);
 
         bool isDiffParam = (!param->findModifier<NoDiffModifier>());
         if (isDiffParam)
@@ -13416,13 +13416,13 @@ ArgsWithDirectionInfo getImaginaryArgsToBackwardDerivative(
                         visitor->getASTBuilder(),
                         pairType->getPrimalType());
 
-                    direction = ParameterDirection::kParameterDirection_In;
+                    direction = ParamPassingMode::In;
                 }
                 else
                 {
                     // in T : IDifferentiable -> inout DifferentialPair<T>
                     // inout T : IDifferentiable -> inout DifferentialPair<T>
-                    direction = ParameterDirection::kParameterDirection_InOut;
+                    direction = ParamPassingMode::BorrowInOut;
                 }
             }
             else if (auto refPairType = as<DifferentialPtrPairType>(diffPair))
@@ -13446,7 +13446,7 @@ ArgsWithDirectionInfo getImaginaryArgsToBackwardDerivative(
             // no_diff inout T -> in T
             // no_diff in T -> in T
             //
-            direction = ParameterDirection::kParameterDirection_In;
+            direction = ParamPassingMode::In;
         }
 
         imaginaryArguments.add(arg);
@@ -13461,7 +13461,7 @@ ArgsWithDirectionInfo getImaginaryArgsToBackwardDerivative(
         arg->type.type = diffReturnType;
         arg->loc = loc;
         imaginaryArguments.add(arg);
-        expectedParamDirections.add(ParameterDirection::kParameterDirection_In);
+        expectedParamDirections.add(ParamPassingMode::In);
     }
 
     return {imaginaryArguments, expectedParamDirections, thisArgExpr, thisTypeDirection};
diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index 235b57ca6..511834cef 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -2966,7 +2966,7 @@ Expr* SemanticsVisitor::CheckInvokeExprWithCheckedOperands(InvokeExpr* expr)
                 }
                 compareMemoryQualifierOfParamToArgument(paramDecl, argExpr);
 
-                if (as<OutTypeBase>(paramType) || as<RefParamType>(paramType))
+                if (as<OutParamTypeBase>(paramType) || as<RefParamType>(paramType))
                 {
                     // `out`, `inout`, and `ref` parameters currently require
                     // an *exact* match on the type of the argument.
@@ -2994,7 +2994,7 @@ Expr* SemanticsVisitor::CheckInvokeExprWithCheckedOperands(InvokeExpr* expr)
                             //
                             // An argument can be made that transformation shouldn't apply to the
                             // ref scenario in general.
-                            if (implicitCastExpr && as<OutTypeBase>(paramType) &&
+                            if (implicitCastExpr && as<OutParamTypeBase>(paramType) &&
                                 _canLValueCoerce(
                                     implicitCastExpr->arguments[0]->type,
                                     implicitCastExpr->type))
@@ -3579,7 +3579,7 @@ Type* SemanticsVisitor::_toDifferentialParamType(Type* primalParamType)
     // mode, and are not a proper part of the Slang type system
     // (at least not at this time).
     //
-    if (auto primalParamWrapperType = as<ParamDirectionType>(primalParamType))
+    if (auto primalParamWrapperType = as<ParamPassingModeType>(primalParamType))
     {
         // Some parameter-passing modes do not naturally lend themselves
         // to being differentiated - most notably, `ref` parameters.
@@ -3609,13 +3609,13 @@ Type* SemanticsVisitor::_toDifferentialParamType(Type* primalParamType)
         //
         if (as<OutType>(primalParamWrapperType))
         {
-            return m_astBuilder->getOutType(diffValueType);
+            return m_astBuilder->getOutParamType(diffValueType);
         }
-        else if (as<InOutType>(primalParamWrapperType))
+        else if (as<BorrowInOutParamType>(primalParamWrapperType))
         {
-            return m_astBuilder->getInOutType(diffValueType);
+            return m_astBuilder->getBorrowInOutParamType(diffValueType);
         }
-        else if (as<ConstRefParamType>(primalParamWrapperType))
+        else if (as<BorrowInParamType>(primalParamWrapperType))
         {
             return m_astBuilder->getConstRefParamType(diffValueType);
         }
@@ -3753,9 +3753,9 @@ Type* SemanticsVisitor::getBackwardDiffFuncType(FuncType* originalType)
             if (as<DifferentialPairType>(derivType))
             {
                 // An `in` differentiable parameter becomes an `inout` parameter.
-                derivType = m_astBuilder->getInOutType(derivType);
+                derivType = m_astBuilder->getBorrowInOutParamType(derivType);
             }
-            else if (auto inoutType = as<InOutType>(derivType))
+            else if (auto inoutType = as<BorrowInOutParamType>(derivType))
             {
                 if (!as<DifferentialPairType>(inoutType->getValueType()))
                 {
diff --git a/source/slang/slang-check-impl.h b/source/slang/slang-check-impl.h
index dd5c816b1..d5d9c2372 100644
--- a/source/slang/slang-check-impl.h
+++ b/source/slang/slang-check-impl.h
@@ -1913,10 +1913,10 @@ public:
         DeclRef<Decl> candidateMethod; // The method that was considered but failed
         Type* actualType = nullptr;    // For type mismatches: the actual type found
         Type* expectedType = nullptr;  // For type mismatches: the expected type
-        ParameterDirection actualDir =
-            kParameterDirection_In; // For direction mismatches: the actual direction
-        ParameterDirection expectedDir =
-            kParameterDirection_In;     // For direction mismatches: the expected direction
+        ParamPassingMode actualDir =
+            ParamPassingMode::In; // For direction mismatches: the actual direction
+        ParamPassingMode expectedDir =
+            ParamPassingMode::In;       // For direction mismatches: the expected direction
         ParamDecl* paramDecl = nullptr; // For direction mismatches: the parameter declaration
     };
 
diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp
index ebda2d637..7686a4703 100644
--- a/source/slang/slang-check-modifier.cpp
+++ b/source/slang/slang-check-modifier.cpp
@@ -1306,7 +1306,7 @@ ASTNodeType getModifierConflictGroupKind(ASTNodeType modifierType)
         return modifierType;
     case ASTNodeType::OutModifier:
     case ASTNodeType::RefModifier:
-    case ASTNodeType::ConstRefModifier:
+    case ASTNodeType::BorrowModifier:
     case ASTNodeType::InOutModifier:
         return ASTNodeType::OutModifier;
 
@@ -1415,7 +1415,7 @@ bool isModifierAllowedOnDecl(bool isGLSLInput, ASTNodeType modifierType, Decl* d
         [[fallthrough]];
 
     case ASTNodeType::RefModifier:
-    case ASTNodeType::ConstRefModifier:
+    case ASTNodeType::BorrowModifier:
     case ASTNodeType::GLSLBufferModifier:
     case ASTNodeType::GLSLPatchModifier:
         return (as<VarDeclBase>(decl) && isGlobalDecl(decl)) || as<ParamDecl>(decl) ||
diff --git a/source/slang/slang-check-overload.cpp b/source/slang/slang-check-overload.cpp
index 2ad31c9d1..a13442135 100644
--- a/source/slang/slang-check-overload.cpp
+++ b/source/slang/slang-check-overload.cpp
@@ -632,9 +632,9 @@ static QualType getParamQualType(ASTBuilder* astBuilder, DeclRef<ParamDecl> para
     bool isLVal = false;
     switch (getParameterDirection(param.getDecl()))
     {
-    case kParameterDirection_InOut:
-    case kParameterDirection_Out:
-    case kParameterDirection_Ref:
+    case ParamPassingMode::BorrowInOut:
+    case ParamPassingMode::Out:
+    case ParamPassingMode::Ref:
         isLVal = true;
         break;
     }
@@ -647,11 +647,11 @@ static QualType getParamQualType(Type* paramType)
     // the accessors for the parameters of a `FuncType` should
     // directly return a `QualType` for each parameter rather than
     // a plain `Type` that potentially includes a wrapping
-    // `ParamDirectionType`.
+    // `ParamPassingModeType`.
     //
     // In addition, the determination of what value category a reference
     // to a parameter should be (and thus what the `QualType` sould be)
-    // should be driven by computing the `ParameterDirection` first,
+    // should be driven by computing the `ParamPassingMode` first,
     // and then using the direction to determine the value category
     // (so as to isolate the code that needs to care about the wrapper
     // types to just the computation of the dirction).
@@ -661,10 +661,10 @@ static QualType getParamQualType(Type* paramType)
     //
     bool isLVal = false;
     Type* valueType = paramType;
-    if (auto paramDirType = as<ParamDirectionType>(paramType))
+    if (auto paramDirType = as<ParamPassingModeType>(paramType))
     {
         valueType = paramDirType->getValueType();
-        if (as<InOutParamType>(paramDirType))
+        if (as<BorrowInOutParamType>(paramDirType))
             isLVal = true;
         if (as<OutParamType>(paramDirType))
             isLVal = true;
@@ -3031,7 +3031,7 @@ Expr* SemanticsVisitor::ResolveInvoke(InvokeExpr* expr)
         // `openExistential` operation that was applied to `out` arguments.
         //
         auto funcType = context.bestCandidate->funcType;
-        ShortList<ParameterDirection> paramDirections;
+        ShortList<ParamPassingMode> paramDirections;
         if (funcType)
         {
             for (Index i = 0; i < funcType->getParamCount(); i++)
@@ -3053,10 +3053,10 @@ Expr* SemanticsVisitor::ResolveInvoke(InvokeExpr* expr)
             {
                 switch (paramDirections[i])
                 {
-                case kParameterDirection_Out:
-                case kParameterDirection_InOut:
-                case kParameterDirection_Ref:
-                case kParameterDirection_ConstRef:
+                case ParamPassingMode::Out:
+                case ParamPassingMode::BorrowInOut:
+                case ParamPassingMode::Ref:
+                case ParamPassingMode::BorrowIn:
                     break;
                 default:
                     continue;
diff --git a/source/slang/slang-check-shader.cpp b/source/slang/slang-check-shader.cpp
index 7b6ed2261..b714826de 100644
--- a/source/slang/slang-check-shader.cpp
+++ b/source/slang/slang-check-shader.cpp
@@ -843,15 +843,15 @@ Type* getParamTypeWithDirectionWrapper(ASTBuilder* astBuilder, DeclRef<VarDeclBa
     auto direction = getParameterDirection(paramDeclRef.getDecl());
     switch (direction)
     {
-    case kParameterDirection_In:
+    case ParamPassingMode::In:
         return result;
-    case kParameterDirection_ConstRef:
+    case ParamPassingMode::BorrowIn:
         return astBuilder->getConstRefParamType(result);
-    case kParameterDirection_Out:
-        return astBuilder->getOutType(result);
-    case kParameterDirection_InOut:
-        return astBuilder->getInOutType(result);
-    case kParameterDirection_Ref:
+    case ParamPassingMode::Out:
+        return astBuilder->getOutParamType(result);
+    case ParamPassingMode::BorrowInOut:
+        return astBuilder->getBorrowInOutParamType(result);
+    case ParamPassingMode::Ref:
         return astBuilder->getRefParamType(result);
     default:
         return result;
diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h
index b1bb22ef3..d31247623 100644
--- a/source/slang/slang-diagnostic-defs.h
+++ b/source/slang/slang-diagnostic-defs.h
@@ -2224,8 +2224,8 @@ DIAGNOSTIC(
 DIAGNOSTIC(
     38034,
     Error,
-    cannotUseConstRefOnDifferentiableParameter,
-    "cannot use '__constref' on a differentiable parameter.")
+    cannotUseBorrowInOnDifferentiableParameter,
+    "cannot use 'borrow in' on a differentiable parameter.")
 DIAGNOSTIC(
     38034,
     Error,
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index 08caedb94..77c45a6d9 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -1619,7 +1619,7 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst)
         auto ptrType = load->getPtr()->getDataType();
         if (load->getPtr()->getOp() == kIROp_GlobalParam)
         {
-            if (ptrType->getOp() == kIROp_ConstRefType)
+            if (ptrType->getOp() == kIROp_BorrowInParamType)
                 return true;
             if (auto ptrTypeBase = as<IRPtrTypeBase>(ptrType))
             {
@@ -3879,24 +3879,24 @@ void CLikeSourceEmitter::emitParamTypeImpl(IRType* type, String const& name)
     // encoded as a parameter of pointer type, so
     // we need to decode that here.
     //
-    if (auto outType = as<IROutType>(type))
+    if (auto outType = as<IROutParamType>(type))
     {
         m_writer->emit("out ");
         type = outType->getValueType();
     }
-    else if (auto inOutType = as<IRInOutType>(type))
+    else if (auto inOutType = as<IRBorrowInOutParamType>(type))
     {
         m_writer->emit("inout ");
         type = inOutType->getValueType();
     }
-    else if (auto refType = as<IRRefType>(type))
+    else if (auto refType = as<IRRefParamType>(type))
     {
         // Note: There is no HLSL/GLSL equivalent for by-reference parameters,
         // so we don't actually expect to encounter these in user code.
         m_writer->emit("inout ");
         type = refType->getValueType();
     }
-    else if (auto constRefType = as<IRConstRefType>(type))
+    else if (auto constRefType = as<IRBorrowInParamType>(type))
     {
         type = constRefType->getValueType();
     }
@@ -4948,7 +4948,7 @@ void CLikeSourceEmitter::emitGlobalParam(IRGlobalParam* varDecl)
             varType = ptrType->getValueType();
             break;
         default:
-            if (as<IROutTypeBase>(ptrType))
+            if (as<IROutParamTypeBase>(ptrType))
                 varType = ptrType->getValueType();
             break;
         }
diff --git a/source/slang/slang-emit-cpp.cpp b/source/slang/slang-emit-cpp.cpp
index 66829308d..c6d2bc6f3 100644
--- a/source/slang/slang-emit-cpp.cpp
+++ b/source/slang/slang-emit-cpp.cpp
@@ -305,7 +305,7 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
         }
     case kIROp_NativePtrType:
     case kIROp_PtrType:
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInParamType:
         {
             // Special note on `constref` types and why they are not emitted
             // as a `const` pointer:
@@ -499,8 +499,8 @@ void CPPSourceEmitter::useType(IRType* type)
             type = static_cast<IRPtrType*>(type)->getValueType();
             break;
         }
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
         {
             type = static_cast<IRPtrTypeBase*>(type)->getValueType();
             break;
@@ -1151,16 +1151,16 @@ void CPPSourceEmitter::_emitType(IRType* type, DeclaratorInfo* declarator)
             break;
         }
     case kIROp_PtrType:
-    case kIROp_InOutType:
-    case kIROp_OutType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_OutParamType:
         {
             auto ptrType = cast<IRPtrTypeBase>(type);
             PtrDeclaratorInfo ptrDeclarator(declarator);
             _emitType(ptrType->getValueType(), &ptrDeclarator);
         }
         break;
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
         {
             auto ptrType = cast<IRPtrTypeBase>(type);
             PtrDeclaratorInfo refDeclarator(declarator);
diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp
index eb6d4c694..d2dc53a84 100644
--- a/source/slang/slang-emit-glsl.cpp
+++ b/source/slang/slang-emit-glsl.cpp
@@ -1218,8 +1218,10 @@ void GLSLSourceEmitter::_maybeEmitGLSLBuiltin(IRGlobalParam* var, UnownedStringS
         // GLSL has some specific requirements about how these are declared,
         // Do it manually here to avoid `emitGlobalParam` emitting
         // decorations/layout we are not allowed to output.
-        auto varType =
-            composeGetters<IRType>(var, &IRGlobalParam::getDataType, &IROutTypeBase::getValueType);
+        auto varType = composeGetters<IRType>(
+            var,
+            &IRGlobalParam::getDataType,
+            &IROutParamTypeBase::getValueType);
         SLANG_ASSERT(varType && "Indices mesh output dind't have an 'out' type");
 
         m_writer->emit("out ");
@@ -1230,7 +1232,7 @@ void GLSLSourceEmitter::_maybeEmitGLSLBuiltin(IRGlobalParam* var, UnownedStringS
     {
         // Is this an output? We do not need to define input.
         auto varType = var->getDataType();
-        if (auto outType = as<IROutType>(varType))
+        if (auto outType = as<IROutParamType>(varType))
         {
             varType = outType->getValueType();
             m_writer->emit("out ");
@@ -3229,7 +3231,7 @@ void GLSLSourceEmitter::emitVectorTypeNameImpl(IRType* elementType, IRIntegerVal
 
 void GLSLSourceEmitter::emitTypeImpl(IRType* type, const StringSliceLoc* nameAndLoc)
 {
-    if (auto refType = as<IRRefType>(type))
+    if (auto refType = as<IRRefParamType>(type))
     {
         _requireGLSLExtension(UnownedStringSlice("GL_EXT_spirv_intrinsics"));
         m_writer->emit("spirv_by_reference ");
@@ -3240,7 +3242,7 @@ void GLSLSourceEmitter::emitTypeImpl(IRType* type, const StringSliceLoc* nameAnd
 
 void GLSLSourceEmitter::emitParamTypeImpl(IRType* type, String const& name)
 {
-    if (auto refType = as<IRRefType>(type))
+    if (auto refType = as<IRRefParamType>(type))
     {
         type = refType->getValueType();
 
@@ -3471,9 +3473,9 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type)
             emitSimpleTypeImpl(cast<IRAtomicType>(type)->getElementType());
             return;
         }
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInParamType:
         {
-            emitSimpleTypeImpl(as<IRConstRefType>(type)->getValueType());
+            emitSimpleTypeImpl(as<IRBorrowInParamType>(type)->getValueType());
             return;
         }
     default:
diff --git a/source/slang/slang-emit-hlsl.cpp b/source/slang/slang-emit-hlsl.cpp
index 240b5c0cb..a5d634ebf 100644
--- a/source/slang/slang-emit-hlsl.cpp
+++ b/source/slang/slang-emit-hlsl.cpp
@@ -1476,9 +1476,9 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type)
             m_writer->emit(">");
             return;
         }
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInParamType:
         {
-            emitSimpleTypeImpl(as<IRConstRefType>(type)->getValueType());
+            emitSimpleTypeImpl(as<IRBorrowInParamType>(type)->getValueType());
             return;
         }
     default:
diff --git a/source/slang/slang-emit-metal.cpp b/source/slang/slang-emit-metal.cpp
index 71de65ee7..e992d17f5 100644
--- a/source/slang/slang-emit-metal.cpp
+++ b/source/slang/slang-emit-metal.cpp
@@ -1180,13 +1180,13 @@ void MetalSourceEmitter::emitSimpleTypeImpl(IRType* type)
             return;
         }
     case kIROp_PtrType:
-    case kIROp_InOutType:
-    case kIROp_OutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_OutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
         {
             auto ptrType = cast<IRPtrTypeBase>(type);
-            if (type->getOp() == kIROp_ConstRefType)
+            if (type->getOp() == kIROp_BorrowInParamType)
             {
                 m_writer->emit("const ");
             }
diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp
index ea49cb08c..b3232de93 100644
--- a/source/slang/slang-emit-spirv.cpp
+++ b/source/slang/slang-emit-spirv.cpp
@@ -1793,10 +1793,10 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
                 return emitOpTypeFloat(inst, SpvLiteralInteger::from32(int32_t(i.width)));
             }
         case kIROp_PtrType:
-        case kIROp_RefType:
-        case kIROp_ConstRefType:
-        case kIROp_OutType:
-        case kIROp_InOutType:
+        case kIROp_RefParamType:
+        case kIROp_BorrowInParamType:
+        case kIROp_OutParamType:
+        case kIROp_BorrowInOutParamType:
             {
                 SpvStorageClass storageClass = SpvStorageClassFunction;
                 auto ptrType = as<IRPtrTypeBase>(inst);
@@ -8167,10 +8167,10 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
             break;
 
         case kIROp_PtrType:
-        case kIROp_RefType:
-        case kIROp_ConstRefType:
-        case kIROp_OutType:
-        case kIROp_InOutType:
+        case kIROp_RefParamType:
+        case kIROp_BorrowInParamType:
+        case kIROp_OutParamType:
+        case kIROp_BorrowInOutParamType:
             if (auto ptrType = as<IRPtrTypeBase>(type))
                 return checkTypeNeedsStorageCapability(
                     ptrType->getValueType(),
diff --git a/source/slang/slang-emit-vm.cpp b/source/slang/slang-emit-vm.cpp
index 36fa1cea6..1602fbfb8 100644
--- a/source/slang/slang-emit-vm.cpp
+++ b/source/slang/slang-emit-vm.cpp
@@ -356,9 +356,9 @@ public:
         case kIROp_UInt64Type:
         case kIROp_UIntPtrType:
         case kIROp_PtrType:
-        case kIROp_OutType:
-        case kIROp_InOutType:
-        case kIROp_RefType:
+        case kIROp_OutParamType:
+        case kIROp_BorrowInOutParamType:
+        case kIROp_RefParamType:
         case kIROp_NativePtrType:
             extCode.scalarType = kSlangByteCodeScalarTypeUnsignedInt;
             extCode.scalarBitWidth = 3;
diff --git a/source/slang/slang-emit-wgsl.cpp b/source/slang/slang-emit-wgsl.cpp
index b115c723a..3cebae97c 100644
--- a/source/slang/slang-emit-wgsl.cpp
+++ b/source/slang/slang-emit-wgsl.cpp
@@ -567,10 +567,10 @@ void WGSLSourceEmitter::emitSimpleTypeImpl(IRType* type)
         }
 
     case kIROp_PtrType:
-    case kIROp_InOutType:
-    case kIROp_OutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_OutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
         {
             auto ptrType = cast<IRPtrTypeBase>(type);
             m_writer->emit("ptr<");
diff --git a/source/slang/slang-ir-addr-inst-elimination.cpp b/source/slang/slang-ir-addr-inst-elimination.cpp
index 51477419b..b4e02465a 100644
--- a/source/slang/slang-ir-addr-inst-elimination.cpp
+++ b/source/slang/slang-ir-addr-inst-elimination.cpp
@@ -98,7 +98,7 @@ struct AddressInstEliminationContext
         auto call = as<IRCall>(use->getUser());
 
         // Don't change the use if addr is a non mutable address.
-        if (as<IRConstRefType>(getRootAddr(addr)->getDataType()))
+        if (as<IRBorrowInParamType>(getRootAddr(addr)->getDataType()))
         {
             return;
         }
@@ -126,7 +126,7 @@ struct AddressInstEliminationContext
         {
             for (auto inst : block->getChildren())
             {
-                if (as<IRConstRefType>(getRootAddr(inst)->getDataType()))
+                if (as<IRBorrowInParamType>(getRootAddr(inst)->getDataType()))
                     continue;
                 if (auto ptrType = as<IRPtrTypeBase>(inst->getDataType()))
                 {
diff --git a/source/slang/slang-ir-autodiff-fwd.cpp b/source/slang/slang-ir-autodiff-fwd.cpp
index cd729ce6b..946d5e7cb 100644
--- a/source/slang/slang-ir-autodiff-fwd.cpp
+++ b/source/slang/slang-ir-autodiff-fwd.cpp
@@ -79,7 +79,7 @@ void ForwardDiffTranscriber::generateTrivialFwdDiffFunc(IRFunc* primalFunc, IRFu
     };
     for (auto param : diffParams)
     {
-        if (auto outType = as<IROutTypeBase>(param->getFullType()))
+        if (auto outType = as<IROutParamTypeBase>(param->getFullType()))
         {
             if (isRelevantDifferentialPair(outType))
             {
@@ -794,7 +794,7 @@ InstPair ForwardDiffTranscriber::transcribeCall(IRBuilder* builder, IRCall* orig
                     markDiffPairTypeInst(&argBuilder, srcVar, pairValType);
 
                     auto diffArg = findOrTranscribeDiffInst(&argBuilder, origArg);
-                    if (ptrParamType->getOp() == kIROp_InOutType)
+                    if (ptrParamType->getOp() == kIROp_BorrowInOutParamType)
                     {
                         // Set initial value.
                         auto primalVal = argBuilder.emitLoad(primalArg);
@@ -814,7 +814,7 @@ InstPair ForwardDiffTranscriber::transcribeCall(IRBuilder* builder, IRCall* orig
                         auto store = argBuilder.emitStore(srcVar, initVal);
                         markDiffPairTypeInst(&argBuilder, store, pairValType);
                     }
-                    if (as<IROutTypeBase>(ptrParamType))
+                    if (as<IROutParamTypeBase>(ptrParamType))
                     {
                         // Read back new value.
                         auto newVal = afterBuilder.emitLoad(srcVar);
@@ -1806,7 +1806,7 @@ void insertTempVarForMutableParams(IRModule* module, IRFunc* func)
     List<IRParam*> params;
     for (auto param : firstBlock->getParams())
     {
-        if (const auto ptrType = as<IROutTypeBase>(param->getDataType()))
+        if (const auto ptrType = as<IROutParamTypeBase>(param->getDataType()))
         {
             params.add(param);
         }
@@ -1818,7 +1818,7 @@ void insertTempVarForMutableParams(IRModule* module, IRFunc* func)
         auto tempVar = builder.emitVar(ptrType->getValueType());
         param->replaceUsesWith(tempVar);
         mapParamToTempVar[param] = tempVar;
-        if (ptrType->getOp() != kIROp_OutType)
+        if (ptrType->getOp() != kIROp_OutParamType)
         {
             builder.emitStore(tempVar, builder.emitLoad(param));
         }
@@ -2315,7 +2315,7 @@ InstPair ForwardDiffTranscriber::transcribeFuncParam(
 
             IRInst* primalInitVal = nullptr;
             IRInst* diffInitVal = nullptr;
-            if (as<IROutType>(diffPairType))
+            if (as<IROutParamType>(diffPairType))
             {
                 primalInitVal = builder->emitDefaultConstruct(ptrInnerPairType->getValueType());
                 diffInitVal = builder->emitDefaultConstructRaw(diffType);
diff --git a/source/slang/slang-ir-autodiff-primal-hoist.cpp b/source/slang/slang-ir-autodiff-primal-hoist.cpp
index e9eda21da..5dea7f61b 100644
--- a/source/slang/slang-ir-autodiff-primal-hoist.cpp
+++ b/source/slang/slang-ir-autodiff-primal-hoist.cpp
@@ -2814,7 +2814,7 @@ bool DefaultCheckpointPolicy::canRecompute(UseOrPseudoUse use)
         {
             // An exception is a load of a constref parameter, which should
             // remain constant throughout the function.
-            if (as<IRConstRefType>(getRootAddr(ptr)->getDataType()))
+            if (as<IRBorrowInParamType>(getRootAddr(ptr)->getDataType()))
                 return true;
             if (isInstInPrimalOrTransposedParameterBlocks(ptr))
                 return false;
diff --git a/source/slang/slang-ir-autodiff-rev.cpp b/source/slang/slang-ir-autodiff-rev.cpp
index ca768cd66..ab964aef6 100644
--- a/source/slang/slang-ir-autodiff-rev.cpp
+++ b/source/slang/slang-ir-autodiff-rev.cpp
@@ -59,7 +59,7 @@ IRFuncType* BackwardDiffPrimalTranscriber::differentiateFunctionType(
             (IRType*)specializeWithGeneric(*builder, intermediateType, as<IRGeneric>(outerGeneric));
     }
 
-    auto outType = builder->getOutType(intermediateType);
+    auto outType = builder->getOutParamType(intermediateType);
     List<IRType*> paramTypes;
     for (UInt i = 0; i < funcType->getParamCount(); i++)
     {
@@ -308,7 +308,7 @@ static IRType* _getPrimalTypeFromNoDiffType(
     IRType* origType)
 {
     IRType* valueType = origType;
-    auto ptrType = as<IROutTypeBase>(valueType);
+    auto ptrType = as<IROutParamTypeBase>(valueType);
     if (ptrType)
         valueType = ptrType->getValueType();
 
@@ -354,7 +354,7 @@ IRType* BackwardDiffTranscriberBase::transcribeParamTypeForPropagateFunc(
     IRBuilder* builder,
     IRType* paramType)
 {
-    if (auto outType = as<IROutType>(paramType))
+    if (auto outType = as<IROutParamType>(paramType))
     {
         auto valueType = outType->getValueType();
         auto diffValueType = differentiateType(builder, valueType);
@@ -363,7 +363,7 @@ IRType* BackwardDiffTranscriberBase::transcribeParamTypeForPropagateFunc(
 
     auto maybeConvertInOutTypeToValueType = [](IRType* type)
     {
-        if (auto inoutType = as<IRInOutType>(type))
+        if (auto inoutType = as<IRBorrowInOutParamType>(type))
             return inoutType->getValueType();
         return type;
     };
@@ -376,7 +376,7 @@ IRType* BackwardDiffTranscriberBase::transcribeParamTypeForPropagateFunc(
     if (diffPairType)
     {
         if (!asRelevantPtrType(diffPairType) && !as<IRDifferentialPtrPairType>(diffPairType))
-            return builder->getInOutType(diffPairType);
+            return builder->getBorrowInOutParamType(diffPairType);
         return diffPairType;
     }
     auto primalType = (IRType*)findOrTranscribePrimalInst(builder, paramType);
@@ -515,7 +515,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF
 
             // Fetch primal values to use as arguments in primal func call.
             IRInst* primalArg = param;
-            if (!as<IROutType>(primalParamType) && !as<IRConstRefType>(primalParamType))
+            if (!as<IROutParamType>(primalParamType) && !as<IRBorrowInParamType>(primalParamType))
             {
                 // As long as the primal parameter is not an out or constref type,
                 // we need to fetch the primal value from the parameter.
@@ -537,7 +537,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF
                 // value of the temp var, otherwise the temp var will be uninitialized which could
                 // cause undefined behavior in the primal function.
                 //
-                if (!as<IROutType>(primalParamType))
+                if (!as<IROutParamType>(primalParamType))
                     builder.emitStore(tempVar, primalArg);
 
                 primalArgs.add(tempVar);
@@ -588,7 +588,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF
 
     auto primalFuncType = builder.getFuncType(primalTypes, primalResultType);
     primalArgs.add(intermediateVar);
-    primalTypes.add(builder.getOutType(intermediateType));
+    primalTypes.add(builder.getOutParamType(intermediateType));
     auto primalFunc =
         builder.emitBackwardDifferentiatePrimalInst(primalFuncType, specializedOriginalFunc);
     builder.emitCallInst(primalResultType, primalFunc, primalArgs);
@@ -1066,8 +1066,8 @@ ParameterBlockTransposeInfo BackwardDiffTranscriberBase::splitAndTransposeParame
 
         // Common logic that computes all the important types we care about.
         IRDifferentialPairType* diffPairType = as<IRDifferentialPairType>(fwdParam->getDataType());
-        auto inoutType = as<IRInOutType>(fwdParam->getDataType());
-        auto outType = as<IROutType>(fwdParam->getDataType());
+        auto inoutType = as<IRBorrowInOutParamType>(fwdParam->getDataType());
+        auto outType = as<IROutParamType>(fwdParam->getDataType());
         if (inoutType)
             diffPairType = as<IRDifferentialPairType>(inoutType->getValueType());
         else if (outType)
@@ -1094,7 +1094,7 @@ ParameterBlockTransposeInfo BackwardDiffTranscriberBase::splitAndTransposeParame
                 auto diffParam = builder->emitParam(diffType);
                 copyNameHintAndDebugDecorations(diffParam, fwdParam);
                 result.propagateFuncParams.add(diffParam);
-                primalRefReplacement = builder->emitParam(builder->getOutType(primalType));
+                primalRefReplacement = builder->emitParam(builder->getOutParamType(primalType));
                 copyNameHintAndDebugDecorations(primalRefReplacement, fwdParam);
 
                 // Create a local var for read access in pre-transpose code.
@@ -1178,7 +1178,7 @@ ParameterBlockTransposeInfo BackwardDiffTranscriberBase::splitAndTransposeParame
             SLANG_RELEASE_ASSERT(diffPairType);
 
             // Create inout version.
-            auto inoutDiffPairType = builder->getInOutType(diffPairType);
+            auto inoutDiffPairType = builder->getBorrowInOutParamType(diffPairType);
             primalRefReplacement = builder->emitParam(primalType);
             copyNameHintAndDebugDecorations(primalRefReplacement, fwdParam);
 
@@ -1217,7 +1217,7 @@ ParameterBlockTransposeInfo BackwardDiffTranscriberBase::splitAndTransposeParame
             SLANG_ASSERT(inoutType && diffPairType);
 
             // Process differentiable inout parameters.
-            auto primalParam = builder->emitParam(builder->getInOutType(primalType));
+            auto primalParam = builder->emitParam(builder->getBorrowInOutParamType(primalType));
             copyNameHintAndDebugDecorations(primalParam, fwdParam);
             result.primalFuncParams.add(primalParam);
 
diff --git a/source/slang/slang-ir-autodiff-transcriber-base.cpp b/source/slang/slang-ir-autodiff-transcriber-base.cpp
index a4934dc28..9aeb6068e 100644
--- a/source/slang/slang-ir-autodiff-transcriber-base.cpp
+++ b/source/slang/slang-ir-autodiff-transcriber-base.cpp
@@ -347,17 +347,17 @@ IRType* AutoDiffTranscriberBase::_differentiateTypeImpl(IRBuilder* builder, IRTy
     case kIROp_FuncType:
         return differentiateFunctionType(builder, nullptr, as<IRFuncType>(primalType));
 
-    case kIROp_OutType:
+    case kIROp_OutParamType:
         if (auto diffValueType =
-                differentiateType(builder, as<IROutType>(primalType)->getValueType()))
-            return builder->getOutType(diffValueType);
+                differentiateType(builder, as<IROutParamType>(primalType)->getValueType()))
+            return builder->getOutParamType(diffValueType);
         else
             return nullptr;
 
-    case kIROp_InOutType:
+    case kIROp_BorrowInOutParamType:
         if (auto diffValueType =
-                differentiateType(builder, as<IRInOutType>(primalType)->getValueType()))
-            return builder->getInOutType(diffValueType);
+                differentiateType(builder, as<IRBorrowInOutParamType>(primalType)->getValueType()))
+            return builder->getBorrowInOutParamType(diffValueType);
         else
             return nullptr;
 
diff --git a/source/slang/slang-ir-autodiff-transpose.h b/source/slang/slang-ir-autodiff-transpose.h
index 69cb2c8ce..c70374e77 100644
--- a/source/slang/slang-ir-autodiff-transpose.h
+++ b/source/slang/slang-ir-autodiff-transpose.h
@@ -1164,7 +1164,7 @@ struct DiffTransposePass
                 auto pairVal = builder->emitMakeDifferentialPair(pairType, primalVal, diffVal);
                 builder->emitStore(tempVar, pairVal);
                 args.add(tempVar);
-                argTypes.add(builder->getInOutType(pairType));
+                argTypes.add(builder->getBorrowInOutParamType(pairType));
                 argRequiresLoad.add(false);
                 writebacks.add(DiffValWriteBack{instPair->getDiff(), tempVar});
             }
@@ -1193,17 +1193,17 @@ struct DiffTransposePass
                         diffZero));
 
                 args.add(var);
-                argTypes.add(builder->getInOutType(pairType));
+                argTypes.add(builder->getBorrowInOutParamType(pairType));
                 argRequiresLoad.add(true);
             }
             else
             {
-                if (as<IROutType>(paramType))
+                if (as<IROutParamType>(paramType))
                 {
                     args.add(nullptr);
                     argRequiresLoad.add(false);
                 }
-                else if (as<IRInOutType>(paramType))
+                else if (as<IRBorrowInOutParamType>(paramType))
                 {
                     arg = builder->emitLoad(arg);
                     args.add(arg);
diff --git a/source/slang/slang-ir-autodiff-unzip.cpp b/source/slang/slang-ir-autodiff-unzip.cpp
index 4d5903ab1..1db476757 100644
--- a/source/slang/slang-ir-autodiff-unzip.cpp
+++ b/source/slang/slang-ir-autodiff-unzip.cpp
@@ -116,7 +116,7 @@ struct ExtractPrimalFuncContext
         for (UInt i = 0; i < originalFuncType->getParamCount(); i++)
             paramTypes.add(
                 (IRType*)migrationContext.cloneInst(&builder, originalFuncType->getParamType(i)));
-        paramTypes.add(builder.getOutType((IRType*)outIntermediateType));
+        paramTypes.add(builder.getOutParamType((IRType*)outIntermediateType));
         auto resultType =
             (IRType*)migrationContext.cloneInst(&builder, originalFuncType->getResultType());
         auto newFuncType = builder.getFuncType(paramTypes, resultType);
@@ -218,7 +218,8 @@ struct ExtractPrimalFuncContext
         auto paramBlock = func->getFirstBlock();
         builder.setInsertInto(paramBlock);
         auto oldIntermediateParam = func->getLastParam();
-        auto outIntermediary = builder.emitParam(builder.getOutType((IRType*)intermediateType));
+        auto outIntermediary =
+            builder.emitParam(builder.getOutParamType((IRType*)intermediateType));
         oldIntermediateParam->transferDecorationsTo(outIntermediary);
         primalParams.add(outIntermediary);
         oldIntermediateParam->replaceUsesWith(outIntermediary);
diff --git a/source/slang/slang-ir-autodiff-unzip.h b/source/slang/slang-ir-autodiff-unzip.h
index 5685906b6..991cbe6ed 100644
--- a/source/slang/slang-ir-autodiff-unzip.h
+++ b/source/slang/slang-ir-autodiff-unzip.h
@@ -337,7 +337,7 @@ struct DiffUnzipPass
                 SLANG_ASSERT(diffArg);
                 auto primalParamType = resolvedPrimalFuncType->getParamType(ii);
 
-                if (const auto outType = as<IROutType>(primalParamType))
+                if (const auto outType = as<IROutParamType>(primalParamType))
                 {
                     // For `out` parameters that expects an input derivative to propagate
                     // through, we insert a `LoadReverseGradient` inst here to signify the logic
@@ -351,7 +351,7 @@ struct DiffUnzipPass
                     diffBuilder->markInstAsDifferential(gradArg, primalArg->getDataType());
                     diffArgs.add(gradArg);
                 }
-                else if (const auto inoutType = as<IRInOutType>(primalParamType))
+                else if (const auto inoutType = as<IRBorrowInOutParamType>(primalParamType))
                 {
                     // Since arg is split into separate vars, we need a new temp var that
                     // represents the remerged diff pair.
@@ -397,7 +397,7 @@ struct DiffUnzipPass
             }
             else
             {
-                if (as<IRInOutType>(resolvedPrimalFuncType->getParamType(ii)))
+                if (as<IRBorrowInOutParamType>(resolvedPrimalFuncType->getParamType(ii)))
                 {
                     // For 'inout' parameter we need to create a temp var to hold the value
                     // before the primal call. This logic is similar to the 'inout' case for
diff --git a/source/slang/slang-ir-autodiff.cpp b/source/slang/slang-ir-autodiff.cpp
index 011d1fec9..c1b724b9d 100644
--- a/source/slang/slang-ir-autodiff.cpp
+++ b/source/slang/slang-ir-autodiff.cpp
@@ -1721,17 +1721,17 @@ IRType* DifferentiableTypeConformanceContext::differentiateType(
             SLANG_UNIMPLEMENTED_X("Impl");
         }
 
-    case kIROp_OutType:
+    case kIROp_OutParamType:
         if (auto diffValueType =
-                differentiateType(builder, as<IROutType>(primalType)->getValueType()))
-            return builder->getOutType(diffValueType);
+                differentiateType(builder, as<IROutParamType>(primalType)->getValueType()))
+            return builder->getOutParamType(diffValueType);
         else
             return nullptr;
 
-    case kIROp_InOutType:
+    case kIROp_BorrowInOutParamType:
         if (auto diffValueType =
-                differentiateType(builder, as<IRInOutType>(primalType)->getValueType()))
-            return builder->getInOutType(diffValueType);
+                differentiateType(builder, as<IRBorrowInOutParamType>(primalType)->getValueType()))
+            return builder->getBorrowInOutParamType(diffValueType);
         else
             return nullptr;
 
@@ -3301,8 +3301,8 @@ struct AutoDiffPass : public InstPassBase
         {
         case kIROp_ArrayType:
         case kIROp_UnsizedArrayType:
-        case kIROp_InOutType:
-        case kIROp_OutType:
+        case kIROp_BorrowInOutParamType:
+        case kIROp_OutParamType:
         case kIROp_PtrType:
         case kIROp_DifferentialPairType:
         case kIROp_DifferentialPairUserCodeType:
diff --git a/source/slang/slang-ir-autodiff.h b/source/slang/slang-ir-autodiff.h
index 970f490c9..6515b1e1f 100644
--- a/source/slang/slang-ir-autodiff.h
+++ b/source/slang/slang-ir-autodiff.h
@@ -376,8 +376,8 @@ struct DifferentiableTypeConformanceContext
             case kIROp_VectorType:
             case kIROp_ArrayType:
             case kIROp_PtrType:
-            case kIROp_OutType:
-            case kIROp_InOutType:
+            case kIROp_OutParamType:
+            case kIROp_BorrowInOutParamType:
                 origType = (IRType*)origType->getOperand(0);
                 continue;
             default:
@@ -396,8 +396,8 @@ struct DifferentiableTypeConformanceContext
             case kIROp_VectorType:
             case kIROp_ArrayType:
             case kIROp_PtrType:
-            case kIROp_OutType:
-            case kIROp_InOutType:
+            case kIROp_OutParamType:
+            case kIROp_BorrowInOutParamType:
                 origType = (IRType*)origType->getOperand(0);
                 continue;
             default:
diff --git a/source/slang/slang-ir-check-differentiability.cpp b/source/slang/slang-ir-check-differentiability.cpp
index d83d7bb76..81e815044 100644
--- a/source/slang/slang-ir-check-differentiability.cpp
+++ b/source/slang/slang-ir-check-differentiability.cpp
@@ -675,7 +675,7 @@ public:
                         auto paramType = calleeFuncType->getParamType(a);
                         if (!isDifferentiableType(diffTypeContext, paramType))
                             continue;
-                        if (as<IROutTypeBase>(paramType))
+                        if (as<IROutParamTypeBase>(paramType))
                         {
                             if (!canAddressHoldDerivative(diffTypeContext, arg))
                             {
diff --git a/source/slang/slang-ir-defer-buffer-load.cpp b/source/slang/slang-ir-defer-buffer-load.cpp
index ccdfe4538..4736b4e65 100644
--- a/source/slang/slang-ir-defer-buffer-load.cpp
+++ b/source/slang/slang-ir-defer-buffer-load.cpp
@@ -59,7 +59,7 @@ static bool isCompositeTypeContainingArrays(IRType* type)
 bool isTypePreferrableToDeferLoad(CodeGenContext* codeGenContext, IRType* type)
 {
     // If parameter is a pointer/reference, we should consider specialize it.
-    if (as<IROutTypeBase>(type) || as<IRRefType>(type) || as<IRConstRefType>(type))
+    if (as<IROutParamTypeBase>(type) || as<IRRefParamType>(type) || as<IRBorrowInParamType>(type))
         return true;
 
     // We only want to defer loading values that are "large enough" that
diff --git a/source/slang/slang-ir-fix-entrypoint-callsite.cpp b/source/slang/slang-ir-fix-entrypoint-callsite.cpp
index a0ab07928..c0928a2ff 100644
--- a/source/slang/slang-ir-fix-entrypoint-callsite.cpp
+++ b/source/slang/slang-ir-fix-entrypoint-callsite.cpp
@@ -81,7 +81,7 @@ void fixEntryPointCallsites(IRFunc* entryPoint)
             {
                 auto paramType = params[i]->getDataType();
                 auto arg = call->getArg(i);
-                if (auto refType = as<IRConstRefType>(paramType))
+                if (auto refType = as<IRBorrowInParamType>(paramType))
                 {
                     if (!as<IRPtrTypeBase>(arg->getDataType()))
                     {
diff --git a/source/slang/slang-ir-glsl-legalize.cpp b/source/slang/slang-ir-glsl-legalize.cpp
index d87d96da0..bc26b223b 100644
--- a/source/slang/slang-ir-glsl-legalize.cpp
+++ b/source/slang/slang-ir-glsl-legalize.cpp
@@ -1429,7 +1429,7 @@ ScalarizedVal createSimpleGLSLGlobalVarying(
         break;
     case LayoutResourceKind::VaryingOutput:
         addrSpace = systemValueInfo ? AddressSpace::BuiltinOutput : AddressSpace::Output;
-        ptrOpCode = kIROp_OutType;
+        ptrOpCode = kIROp_OutParamType;
         break;
     default:
         break;
@@ -2555,8 +2555,8 @@ static void consolidateParameters(GLSLLegalizationContext* context, List<IRParam
         auto _paramType = _param->getDataType();
         IRType* valueType = _paramType;
 
-        if (as<IROutTypeBase>(_paramType))
-            valueType = as<IROutTypeBase>(_paramType)->getValueType();
+        if (as<IROutParamTypeBase>(_paramType))
+            valueType = as<IROutParamTypeBase>(_paramType)->getValueType();
 
         auto key = builder->createStructKey();
         if (auto nameDecor = _param->findDecoration<IRNameHintDecoration>())
@@ -2600,13 +2600,13 @@ static void consolidateParameters(GLSLLegalizationContext* context, List<IRParam
 
         // If the parameter is an out/inout type, we need to create a pointer type
         IRType* fieldPtrType = nullptr;
-        if (as<IROutType>(_paramType))
+        if (as<IROutParamType>(_paramType))
         {
-            fieldPtrType = builder->getPtrType(kIROp_OutType, fieldType);
+            fieldPtrType = builder->getPtrType(kIROp_OutParamType, fieldType);
         }
-        else if (as<IRInOutType>(_paramType))
+        else if (as<IRBorrowInOutParamType>(_paramType))
         {
-            fieldPtrType = builder->getPtrType(kIROp_InOutType, fieldType);
+            fieldPtrType = builder->getPtrType(kIROp_BorrowInOutParamType, fieldType);
         }
 
         auto fieldAddr =
@@ -2636,7 +2636,8 @@ void consolidateRayTracingParameters(GLSLLegalizationContext* context, IRFunc* f
         if (!isVaryingParameter(paramLayout))
             continue;
         builder->setInsertBefore(firstBlock->getFirstOrdinaryInst());
-        if (as<IROutType>(param->getDataType()) || as<IRInOutType>(param->getDataType()))
+        if (as<IROutParamType>(param->getDataType()) ||
+            as<IRBorrowInOutParamType>(param->getDataType()))
         {
             outParams.add(param);
         }
@@ -3019,7 +3020,7 @@ static void legalizeMeshOutputParam(
                 auto t = composeGetters<IRType>(
                     builtin.param,
                     &IRInst::getFullType,
-                    &IROutTypeBase::getValueType,
+                    &IROutParamTypeBase::getValueType,
                     &IRArrayTypeBase::getElementType);
                 auto key = builder->createStructKey();
                 auto n = builtin.nameDecoration->getStringSlice();
@@ -3386,7 +3387,7 @@ void legalizeEntryPointParameterForGLSL(
     {
         IRType* type = pp->getFullType();
         // Strip out type
-        if (auto outType = as<IROutTypeBase>(type))
+        if (auto outType = as<IROutParamTypeBase>(type))
         {
             type = outType->getValueType();
         }
@@ -3581,7 +3582,7 @@ void legalizeEntryPointParameterForGLSL(
     // Is the parameter type a special pointer type
     // that indicates the parameter is used for `out`
     // or `inout` access?
-    if (as<IROutTypeBase>(paramType))
+    if (as<IROutParamTypeBase>(paramType))
     {
         // Okay, we have the more interesting case here,
         // where the parameter was being passed by reference.
@@ -3592,7 +3593,7 @@ void legalizeEntryPointParameterForGLSL(
         auto localVariable = builder->emitVar(valueType);
         auto localVal = ScalarizedVal::address(localVariable);
 
-        if (const auto inOutType = as<IRInOutType>(paramType))
+        if (const auto inOutType = as<IRBorrowInOutParamType>(paramType))
         {
             // In the `in out` case we need to declare two
             // sets of global variables: one for the `in`
@@ -3663,7 +3664,7 @@ void legalizeEntryPointParameterForGLSL(
         // reference. We simply replace existing uses of the parameter
         // with the real global variable.
         SLANG_ASSERT(
-            ptrType->getOp() == kIROp_ConstRefType ||
+            ptrType->getOp() == kIROp_BorrowInParamType ||
             ptrType->getAddressSpace() == AddressSpace::Input ||
             ptrType->getAddressSpace() == AddressSpace::BuiltinInput);
 
diff --git a/source/slang/slang-ir-glsl-liveness.cpp b/source/slang/slang-ir-glsl-liveness.cpp
index 626313b38..8bde2da01 100644
--- a/source/slang/slang-ir-glsl-liveness.cpp
+++ b/source/slang/slang-ir-glsl-liveness.cpp
@@ -133,10 +133,10 @@ void GLSLLivenessContext::_replaceMarker(IRLiveRangeMarker* markerInst)
     {
         // We didn't find a function for the type, so lets create one. It has a signature of
         //
-        // void func(Ref<ReferencedType> target, int sizeInBytes)
+        // void func(ref ReferencedType target, int sizeInBytes)
 
         IRType* paramTypes[] = {
-            m_builder.getRefType(
+            m_builder.getRefParamType(
                 referencedType,
                 AddressSpace::Generic), ///< Use a reference to the referenced type
             m_spirvIntLiteralType,      ///< The size type
diff --git a/source/slang/slang-ir-inline.cpp b/source/slang/slang-ir-inline.cpp
index f0f940b12..3334197c0 100644
--- a/source/slang/slang-ir-inline.cpp
+++ b/source/slang/slang-ir-inline.cpp
@@ -1017,7 +1017,7 @@ struct TypeInliningPass : InliningPassBase
         const auto op = type->getOp();
         switch (op)
         {
-        case kIROp_RefType:
+        case kIROp_RefParamType:
             {
                 if (callee->findDecoration<IRNoRefInlineDecoration>())
                     return false;
@@ -1230,7 +1230,7 @@ struct GLSLResourceReturnFunctionInliningPass : InliningPassBase
         {
             if (isIllegalGLSLParameterType(param->getDataType()))
                 return true;
-            auto outType = as<IROutTypeBase>(param->getDataType());
+            auto outType = as<IROutParamTypeBase>(param->getDataType());
             if (!outType)
                 continue;
             auto outValueType = outType->getValueType();
diff --git a/source/slang/slang-ir-insert-debug-value-store.cpp b/source/slang/slang-ir-insert-debug-value-store.cpp
index 25b9c03fa..91b7738f1 100644
--- a/source/slang/slang-ir-insert-debug-value-store.cpp
+++ b/source/slang/slang-ir-insert-debug-value-store.cpp
@@ -118,12 +118,12 @@ void DebugValueStoreContext::insertDebugValueStore(IRFunc* func)
         builder.setInsertBefore(firstBlock->getFirstOrdinaryInst());
         auto paramType = param->getDataType();
         bool isRefParam = false;
-        if (auto outType = as<IROutTypeBase>(paramType))
+        if (auto outType = as<IROutParamTypeBase>(paramType))
         {
             isRefParam = true;
             paramType = outType->getValueType();
         }
-        else if (auto ptrType = as<IRConstRefType>(param->getDataType()))
+        else if (auto ptrType = as<IRBorrowInParamType>(param->getDataType()))
         {
             isRefParam = true;
             paramType = ptrType->getValueType();
@@ -146,7 +146,9 @@ void DebugValueStoreContext::insertDebugValueStore(IRFunc* func)
         {
             paramVal = param;
         }
-        else if (as<IRInOutType>(param->getDataType()) || as<IRConstRefType>(param->getDataType()))
+        else if (
+            as<IRBorrowInOutParamType>(param->getDataType()) ||
+            as<IRBorrowInParamType>(param->getDataType()))
         {
             paramVal = builder.emitLoad(param);
         }
diff --git a/source/slang/slang-ir-insts-stable-names.lua b/source/slang/slang-ir-insts-stable-names.lua
index 25d54eb04..cfde8c5fa 100644
--- a/source/slang/slang-ir-insts-stable-names.lua
+++ b/source/slang/slang-ir-insts-stable-names.lua
@@ -59,11 +59,11 @@ return {
 	["Type.Kind.Rate"] = 55,
 	["Type.Kind.Generic"] = 56,
 	["Type.PtrTypeBase.Ptr"] = 57,
-	["Type.PtrTypeBase.Ref"] = 58,
-	["Type.PtrTypeBase.ConstRef"] = 59,
+	["Type.PtrTypeBase.RefParam"] = 58,
+	["Type.PtrTypeBase.BorrowInParam"] = 59,
 	["Type.PtrTypeBase.PseudoPtr"] = 60,
-	["Type.PtrTypeBase.OutTypeBase.Out"] = 61,
-	["Type.PtrTypeBase.OutTypeBase.InOut"] = 62,
+	["Type.PtrTypeBase.OutParamTypeBase.OutParam"] = 61,
+	["Type.PtrTypeBase.OutParamTypeBase.BorrowInOutParam"] = 62,
 	["Type.ComPtr"] = 63,
 	["Type.NativePtr"] = 64,
 	["Type.DescriptorHandle"] = 65,
diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h
index c64f65ccb..7b27f0b56 100644
--- a/source/slang/slang-ir-insts.h
+++ b/source/slang/slang-ir-insts.h
@@ -3735,10 +3735,10 @@ public:
     // Form a ptr type to `valueType` using the same opcode and address space as `ptrWithAddrSpace`.
     IRPtrTypeBase* getPtrTypeWithAddressSpace(IRType* valueType, IRPtrTypeBase* ptrWithAddrSpace);
 
-    IROutType* getOutType(IRType* valueType);
-    IRInOutType* getInOutType(IRType* valueType);
-    IRRefType* getRefType(IRType* valueType, AddressSpace addrSpace);
-    IRConstRefType* getConstRefType(IRType* valueType, AddressSpace addrSpace);
+    IROutParamType* getOutParamType(IRType* valueType);
+    IRBorrowInOutParamType* getBorrowInOutParamType(IRType* valueType);
+    IRRefParamType* getRefParamType(IRType* valueType, AddressSpace addrSpace);
+    IRBorrowInParamType* getBorrowInParamType(IRType* valueType, AddressSpace addrSpace);
     IRPtrType* getPtrType(
         IROp op,
         IRType* valueType,
diff --git a/source/slang/slang-ir-insts.lua b/source/slang/slang-ir-insts.lua
index 5f54707a1..045144e06 100644
--- a/source/slang/slang-ir-insts.lua
+++ b/source/slang/slang-ir-insts.lua
@@ -144,8 +144,8 @@ local insts = {
 				PtrTypeBase = {
 					hoistable = true,
 					{ Ptr = { struct_name = "PtrType", min_operands = 1 } },
-					{ Ref = { struct_name = "RefType", min_operands = 1 } },
-					{ ConstRef = { struct_name = "ConstRefType", min_operands = 1 } },
+					{ RefParam = { struct_name = "RefParamType", min_operands = 1 } },
+					{ BorrowInParam = { struct_name = "BorrowInParamType", min_operands = 1 } },
 					{
 						PseudoPtr = {
 							-- A `PsuedoPtr<T>` logically represents a pointer to a value of type
@@ -157,9 +157,9 @@ local insts = {
 						},
 					},
 					{
-						OutTypeBase = {
-							{ Out = { struct_name = "OutType", min_operands = 1 } },
-							{ InOut = { struct_name = "InOutType", min_operands = 1 } },
+						OutParamTypeBase = {
+							{ OutParam = { struct_name = "OutParamType", min_operands = 1 } },
+							{ BorrowInOutParam = { struct_name = "BorrowInOutParamType", min_operands = 1 } },
 						},
 					},
 				},
diff --git a/source/slang/slang-ir-layout.cpp b/source/slang/slang-ir-layout.cpp
index d3b86a1c6..123dfdea4 100644
--- a/source/slang/slang-ir-layout.cpp
+++ b/source/slang/slang-ir-layout.cpp
@@ -343,10 +343,10 @@ Result IRTypeLayoutRules::calcSizeAndAlignment(
             }
         }
         break;
-    case kIROp_OutType:
-    case kIROp_InOutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_OutParamType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
     case kIROp_RawPointerType:
     case kIROp_PtrType:
     case kIROp_NativePtrType:
diff --git a/source/slang/slang-ir-legalize-array-return-type.cpp b/source/slang/slang-ir-legalize-array-return-type.cpp
index cedd8386f..c42b3dbfd 100644
--- a/source/slang/slang-ir-legalize-array-return-type.cpp
+++ b/source/slang/slang-ir-legalize-array-return-type.cpp
@@ -19,7 +19,7 @@ void makeFuncReturnViaOutParam(IRBuilder& builder, IRFunc* func)
     {
         paramTypes.add(funcType->getParamType(i));
     }
-    auto outParamType = builder.getOutType(funcType->getResultType());
+    auto outParamType = builder.getOutParamType(funcType->getResultType());
     paramTypes.add(outParamType);
 
     auto newFuncType = builder.getFuncType(paramTypes, builder.getVoidType());
diff --git a/source/slang/slang-ir-legalize-types.cpp b/source/slang/slang-ir-legalize-types.cpp
index 27abdeaf0..5168f0466 100644
--- a/source/slang/slang-ir-legalize-types.cpp
+++ b/source/slang/slang-ir-legalize-types.cpp
@@ -2753,7 +2753,7 @@ private:
             // except we wrap the simple type in `Out<...>` to indicate
             // that we are producing an `out` parameter.
             //
-            m_paramTypes.add(m_context->builder->getOutType(t.getSimple()));
+            m_paramTypes.add(m_context->builder->getOutParamType(t.getSimple()));
             break;
 
             // The remaining cases are all simple recursion on the
diff --git a/source/slang/slang-ir-legalize-varying-params.cpp b/source/slang/slang-ir-legalize-varying-params.cpp
index 062330836..39b9b3dd3 100644
--- a/source/slang/slang-ir-legalize-varying-params.cpp
+++ b/source/slang/slang-ir-legalize-varying-params.cpp
@@ -525,11 +525,11 @@ protected:
         // the strategy we take.
         //
         auto paramType = param->getDataType();
-        if (auto inOutType = as<IRInOutType>(paramType))
+        if (auto inOutType = as<IRBorrowInOutParamType>(paramType))
         {
             processInOutParam(param, inOutType);
         }
-        else if (auto outType = as<IROutType>(paramType))
+        else if (auto outType = as<IROutParamType>(paramType))
         {
             processOutParam(param, outType);
         }
@@ -545,16 +545,16 @@ protected:
     // that provides baseline behavior that should in theory work for
     // multiple targets.
     //
-    virtual void processInOutParam(IRParam* param, IRInOutType* inOutType)
+    virtual void processInOutParam(IRParam* param, IRBorrowInOutParamType* inOutType)
     {
         processMutableParam(param, inOutType);
     }
-    virtual void processOutParam(IRParam* param, IROutType* inOutType)
+    virtual void processOutParam(IRParam* param, IROutParamType* inOutType)
     {
         processMutableParam(param, inOutType);
     }
 
-    void processMutableParam(IRParam* param, IROutTypeBase* paramPtrType)
+    void processMutableParam(IRParam* param, IROutParamTypeBase* paramPtrType)
     {
         // The deafult handling of any mutable (`out` or `inout`) parameter
         // will be to introduce a local variable of the corresponding
@@ -577,7 +577,7 @@ protected:
         builder.addSimpleDecoration<IRTempCallArgVarDecoration>(localVar);
         auto localVal = LegalizedVaryingVal::makeAddress(localVar);
 
-        if (const auto inOutType = as<IRInOutType>(paramPtrType))
+        if (const auto inOutType = as<IRBorrowInOutParamType>(paramPtrType))
         {
             // If the parameter was an `inout` and not just an `out`
             // parameter, we will create one more more legal `in`
@@ -1562,7 +1562,7 @@ void depointerizeInputParams(IRFunc* entryPointFunc)
     Index i = 0;
     for (auto param : entryPointFunc->getParams())
     {
-        if (auto constRefType = as<IRConstRefType>(param->getFullType()))
+        if (auto constRefType = as<IRBorrowInParamType>(param->getFullType()))
         {
             switch (constRefType->getValueType()->getOp())
             {
@@ -3555,7 +3555,7 @@ protected:
                     builder.setInsertBefore(
                         entryPoint.entryPointFunc->getFirstBlock()->getFirstOrdinaryInst());
                     const auto annotatedPayloadType = builder.getPtrType(
-                        kIROp_RefType,
+                        kIROp_RefParamType,
                         payloadPtrType->getValueType(),
                         AddressSpace::MetalObjectData);
                     auto packedParam = builder.emitParam(annotatedPayloadType);
@@ -3597,8 +3597,9 @@ protected:
 
                 IRPtrTypeBase* type = as<IRPtrTypeBase>(param->getDataType());
 
-                const auto annotatedPayloadType =
-                    builder.getConstRefType(type->getValueType(), AddressSpace::MetalObjectData);
+                const auto annotatedPayloadType = builder.getBorrowInParamType(
+                    type->getValueType(),
+                    AddressSpace::MetalObjectData);
 
                 param->setFullType(annotatedPayloadType);
             }
@@ -3660,7 +3661,7 @@ protected:
             }
             if (param->findDecorationImpl(kIROp_IndicesDecoration))
             {
-                auto indicesRefType = (IRConstRefType*)param->getDataType();
+                auto indicesRefType = (IRBorrowInParamType*)param->getDataType();
                 auto indicesOutputType = (IRIndicesType*)indicesRefType->getValueType();
                 indicesType = indicesOutputType->getElementType();
                 maxPrimitives = indicesOutputType->getMaxElementCount();
@@ -3670,7 +3671,7 @@ protected:
             }
             if (param->findDecorationImpl(kIROp_PrimitivesDecoration))
             {
-                auto primitivesRefType = (IRConstRefType*)param->getDataType();
+                auto primitivesRefType = (IRBorrowInParamType*)param->getDataType();
                 auto primitivesOutputType = (IRPrimitivesType*)primitivesRefType->getValueType();
                 primitiveType = primitivesOutputType->getElementType();
                 SLANG_ASSERT(primitiveType);
@@ -4036,7 +4037,7 @@ void legalizeVertexShaderOutputParamsForMetal(DiagnosticSink* sink, EntryPointIn
     // handled further down the pipeline
     const bool hasOutParameters = anyOf(
         oldFunc->getParams(),
-        [](auto param) { return as<IROutTypeBase>(param->getFullType()); });
+        [](auto param) { return as<IROutParamTypeBase>(param->getFullType()); });
 
     auto returnType = oldFunc->getResultType();
     if (!as<IRStructType>(returnType) && !hasOutParameters)
diff --git a/source/slang/slang-ir-link.cpp b/source/slang/slang-ir-link.cpp
index a3466c8c7..c46c57043 100644
--- a/source/slang/slang-ir-link.cpp
+++ b/source/slang/slang-ir-link.cpp
@@ -1863,7 +1863,8 @@ void convertAtomicToStorageBuffer(
                         auto funcTypeInst = (user->getOperand(0));
                         auto funcType = funcTypeInst->getFullType();
 
-                        auto paramReplacment = builder.getInOutType(builder.getUIntType());
+                        auto paramReplacment =
+                            builder.getBorrowInOutParamType(builder.getUIntType());
                         funcType->getOperand(1)->replaceUsesWith(paramReplacment);
                         builder.addForceInlineDecoration(funcTypeInst);
 
diff --git a/source/slang/slang-ir-lower-buffer-element-type.cpp b/source/slang/slang-ir-lower-buffer-element-type.cpp
index 128502bd8..83218bade 100644
--- a/source/slang/slang-ir-lower-buffer-element-type.cpp
+++ b/source/slang/slang-ir-lower-buffer-element-type.cpp
@@ -382,7 +382,7 @@ struct LoweredElementTypeContext
         IRBuilder builder(structType);
         builder.setInsertAfter(structType);
         auto func = builder.createFunc();
-        auto refStructType = builder.getRefType(structType, AddressSpace::Generic);
+        auto refStructType = builder.getRefParamType(structType, AddressSpace::Generic);
         auto funcType = builder.getFuncType(1, (IRType**)&refStructType, matrixType);
         func->setFullType(funcType);
         builder.addNameHintDecoration(func, UnownedStringSlice("unpackStorage"));
@@ -435,7 +435,7 @@ struct LoweredElementTypeContext
         IRBuilder builder(structType);
         builder.setInsertAfter(structType);
         auto func = builder.createFunc();
-        auto outStructType = builder.getRefType(structType, AddressSpace::Generic);
+        auto outStructType = builder.getRefParamType(structType, AddressSpace::Generic);
         IRType* paramTypes[] = {outStructType, matrixType};
         auto funcType = builder.getFuncType(2, paramTypes, builder.getVoidType());
         func->setFullType(funcType);
@@ -521,7 +521,7 @@ struct LoweredElementTypeContext
         IRBuilder builder(structType);
         builder.setInsertAfter(structType);
         auto func = builder.createFunc();
-        auto refStructType = builder.getRefType(structType, AddressSpace::Generic);
+        auto refStructType = builder.getRefParamType(structType, AddressSpace::Generic);
         auto funcType = builder.getFuncType(1, (IRType**)&refStructType, arrayType);
         func->setFullType(funcType);
         builder.addNameHintDecoration(func, UnownedStringSlice("unpackStorage"));
@@ -585,7 +585,7 @@ struct LoweredElementTypeContext
         IRBuilder builder(structType);
         builder.setInsertAfter(structType);
         auto func = builder.createFunc();
-        auto outLoweredType = builder.getRefType(structType, AddressSpace::Generic);
+        auto outLoweredType = builder.getRefParamType(structType, AddressSpace::Generic);
         IRType* paramTypes[] = {outLoweredType, structType};
         auto funcType = builder.getFuncType(2, paramTypes, builder.getVoidType());
         func->setFullType(funcType);
@@ -939,7 +939,7 @@ struct LoweredElementTypeContext
                     info.convertLoweredToOriginal.func,
                     UnownedStringSlice("unpackStorage"));
                 builder.addForceInlineDecoration(info.convertLoweredToOriginal.func);
-                auto refLoweredType = builder.getRefType(loweredType, AddressSpace::Generic);
+                auto refLoweredType = builder.getRefParamType(loweredType, AddressSpace::Generic);
                 info.convertLoweredToOriginal.func->setFullType(
                     builder.getFuncType(1, (IRType**)&refLoweredType, type));
                 builder.emitBlock();
@@ -976,7 +976,7 @@ struct LoweredElementTypeContext
                     UnownedStringSlice("packStorage"));
                 builder.addForceInlineDecoration(info.convertOriginalToLowered.func);
 
-                auto outLoweredType = builder.getRefType(loweredType, AddressSpace::Generic);
+                auto outLoweredType = builder.getRefParamType(loweredType, AddressSpace::Generic);
                 IRType* paramTypes[] = {outLoweredType, type};
                 info.convertOriginalToLowered.func->setFullType(
                     builder.getFuncType(2, paramTypes, builder.getVoidType()));
diff --git a/source/slang/slang-ir-lower-out-parameters.cpp b/source/slang/slang-ir-lower-out-parameters.cpp
index 2eec66db5..40e7a8da5 100644
--- a/source/slang/slang-ir-lower-out-parameters.cpp
+++ b/source/slang/slang-ir-lower-out-parameters.cpp
@@ -125,12 +125,12 @@ List<ParamInfo> collectParameterInfo(
         info.outVar = nullptr;
         info.outFieldKey = nullptr;
 
-        if (auto outType = as<IROutTypeBase>(param->getDataType()))
+        if (auto outType = as<IROutParamTypeBase>(param->getDataType()))
         {
             // Handle out/inout parameter
             info.valueType = outType->getValueType();
             info.isOut = true;
-            info.isInOut = (outType->getOp() == kIROp_InOutType);
+            info.isInOut = (outType->getOp() == kIROp_BorrowInOutParamType);
 
             // Create field key for out parameter
             String fieldName = "param";
diff --git a/source/slang/slang-ir-marshal-native-call.cpp b/source/slang/slang-ir-marshal-native-call.cpp
index f19bf2168..8dd1da18f 100644
--- a/source/slang/slang-ir-marshal-native-call.cpp
+++ b/source/slang/slang-ir-marshal-native-call.cpp
@@ -28,10 +28,10 @@ IRType* NativeCallMarshallingContext::getNativeType(IRBuilder& builder, IRType*
                 nativeElementType,
                 arrayType->getElementCount());
         }
-    case kIROp_InOutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
-    case kIROp_OutType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
+    case kIROp_OutParamType:
         return builder.getPtrType(getNativeType(builder, (IRType*)type->getOperand(0)));
     default:
         return type;
@@ -97,10 +97,10 @@ void NativeCallMarshallingContext::marshalManagedValueToNativeValue(
 {
     switch (originalParamType->getOp())
     {
-    case kIROp_InOutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
-    case kIROp_OutType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
+    case kIROp_OutParamType:
         return marshalRefManagedValueToNativeValue(builder, originalArg, args);
     case kIROp_StringType:
         {
@@ -161,9 +161,9 @@ void NativeCallMarshallingContext::marshalManagedValueToNativeResultValue(
 {
     switch (originalArg->getDataType()->getOp())
     {
-    case kIROp_InOutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
         SLANG_UNREACHABLE("out and ref types should be handled before reaching here.");
         break;
     case kIROp_StringType:
diff --git a/source/slang/slang-ir-redundancy-removal.cpp b/source/slang/slang-ir-redundancy-removal.cpp
index 4c10cf246..3b1a731f9 100644
--- a/source/slang/slang-ir-redundancy-removal.cpp
+++ b/source/slang/slang-ir-redundancy-removal.cpp
@@ -133,7 +133,7 @@ bool isAddressMutable(IRInst* inst)
     {
     case kIROp_ParameterBlockType:
     case kIROp_ConstantBufferType:
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInParamType:
         return false; // immutable
 
     // We should consider StructuredBuffer as mutable by default, since the resources may alias.
@@ -279,7 +279,7 @@ static bool eliminateRedundantTemporaryCopyInFunc(IRFunc* func)
                         if (nullptr == param)
                             goto unsafeToOptimize; // IRFunc might be incomplete yet
 
-                        if (auto paramPtrType = as<IRConstRefType>(param->getFullType()))
+                        if (auto paramPtrType = as<IRBorrowInParamType>(param->getFullType()))
                         {
                             if (paramPtrType->getAddressSpace() != loadAddressSpace)
                                 goto unsafeToOptimize; // incompatible address space
@@ -568,7 +568,7 @@ bool isExternallyModifiableAddr(IRInst* rootVar)
     if (!rootVar)
         return false;
 
-    auto ptr = as<IRConstRefType>(rootVar->getDataType());
+    auto ptr = as<IRBorrowInParamType>(rootVar->getDataType());
     if (!ptr)
         return true;
 
diff --git a/source/slang/slang-ir-resolve-texture-format.cpp b/source/slang/slang-ir-resolve-texture-format.cpp
index 09989e892..df30f1dc6 100644
--- a/source/slang/slang-ir-resolve-texture-format.cpp
+++ b/source/slang/slang-ir-resolve-texture-format.cpp
@@ -12,10 +12,10 @@ static IRType* replaceImageElementType(IRInst* originalType, IRInst* newElementT
     case kIROp_ArrayType:
     case kIROp_UnsizedArrayType:
     case kIROp_PtrType:
-    case kIROp_OutType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
-    case kIROp_InOutType:
+    case kIROp_OutParamType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
+    case kIROp_BorrowInOutParamType:
         {
             auto newInnerType =
                 replaceImageElementType(originalType->getOperand(0), newElementType);
diff --git a/source/slang/slang-ir-specialize-arrays.cpp b/source/slang/slang-ir-specialize-arrays.cpp
index edb6cfa28..c2bc4d14e 100644
--- a/source/slang/slang-ir-specialize-arrays.cpp
+++ b/source/slang/slang-ir-specialize-arrays.cpp
@@ -26,19 +26,19 @@ struct ArrayParameterSpecializationCondition : FunctionCallSpecializeCondition
     {
         auto paramType = param->getDataType();
         auto argType = arg->getDataType();
-        if (auto outTypeBase = as<IROutTypeBase>(paramType))
+        if (auto outTypeBase = as<IROutParamTypeBase>(paramType))
         {
             paramType = outTypeBase->getValueType();
             SLANG_ASSERT(as<IRPtrTypeBase>(argType));
             argType = as<IRPtrTypeBase>(argType)->getValueType();
         }
-        else if (auto refType = as<IRRefType>(paramType))
+        else if (auto refType = as<IRRefParamType>(paramType))
         {
             paramType = refType->getValueType();
             SLANG_ASSERT(as<IRPtrTypeBase>(argType));
             argType = as<IRPtrTypeBase>(argType)->getValueType();
         }
-        else if (auto constRefType = as<IRConstRefType>(paramType))
+        else if (auto constRefType = as<IRBorrowInParamType>(paramType))
         {
             paramType = constRefType->getValueType();
             SLANG_ASSERT(as<IRPtrTypeBase>(argType));
diff --git a/source/slang/slang-ir-specialize-function-call.cpp b/source/slang/slang-ir-specialize-function-call.cpp
index aead69258..8b16cd101 100644
--- a/source/slang/slang-ir-specialize-function-call.cpp
+++ b/source/slang/slang-ir-specialize-function-call.cpp
@@ -714,10 +714,10 @@ struct FunctionParameterSpecializationContext
         IRType* resultType = argType;
         switch (paramType->getOp())
         {
-        case kIROp_InOutType:
-        case kIROp_OutType:
-        case kIROp_RefType:
-        case kIROp_ConstRefType:
+        case kIROp_BorrowInOutParamType:
+        case kIROp_OutParamType:
+        case kIROp_RefParamType:
+        case kIROp_BorrowInParamType:
             {
                 auto ptrParamType = as<IRPtrTypeBase>(paramType);
                 argType = as<IRPtrTypeBase>(argType)->getValueType();
diff --git a/source/slang/slang-ir-specialize-resources.cpp b/source/slang/slang-ir-specialize-resources.cpp
index 0ac08236f..e8a13b2e7 100644
--- a/source/slang/slang-ir-specialize-resources.cpp
+++ b/source/slang/slang-ir-specialize-resources.cpp
@@ -349,7 +349,7 @@ struct ResourceOutputSpecializationPass
         for (auto param : func->getParams())
         {
             auto paramType = param->getDataType();
-            auto outType = as<IROutTypeBase>(paramType);
+            auto outType = as<IROutParamTypeBase>(paramType);
             if (!outType)
                 continue;
             auto valueType = outType->getValueType();
@@ -803,11 +803,11 @@ struct ResourceOutputSpecializationPass
         FuncInfo& ioFuncInfo)
     {
         // We only want to specialize in the case where the parameter
-        // is an `out` or `inout` (both inherit from `IROutTypeBase`),
+        // is an `out` or `inout` (both inherit from `IROutParamTypeBase`),
         // and the pointed-to type is a resource.
         //
         auto paramType = param->getDataType();
-        auto outType = as<IROutTypeBase>(paramType);
+        auto outType = as<IROutParamTypeBase>(paramType);
         if (!outType)
             return SpecializeFuncResult::Ok;
         auto valueType = outType->getValueType();
@@ -835,7 +835,7 @@ struct ResourceOutputSpecializationPass
         //
         IRVar* newVar = bodyBuilder.emitVar(valueType);
 
-        if (as<IRInOutType>(outType))
+        if (as<IRBorrowInOutParamType>(outType))
         {
             // If the parameter is an `inout` rather than just
             // an `out`, then we still need a parameter to
diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp
index f795a6559..6bdd02d73 100644
--- a/source/slang/slang-ir-spirv-legalize.cpp
+++ b/source/slang/slang-ir-spirv-legalize.cpp
@@ -316,7 +316,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             {
                 // Skip load's for referenced `Input` variables since a ref implies
                 // passing as is, which needs to be a pointer (pass as is).
-                if (user->getDataType() && user->getDataType()->getOp() == kIROp_RefType &&
+                if (user->getDataType() && user->getDataType()->getOp() == kIROp_RefParamType &&
                     (addressSpace == AddressSpace::Input ||
                      addressSpace == AddressSpace::BuiltinInput))
                 {
@@ -943,7 +943,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                     if (funcType)
                     {
                         if (funcType->getParamCount() > i &&
-                            as<IRRefType>(funcType->getParamType(i)))
+                            as<IRRefParamType>(funcType->getParamType(i)))
                         {
                             // If we are passing an address from a structured buffer as a
                             // ref argument, pass the original pointer as is.
@@ -968,7 +968,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             //
             // If callee doesn't modify the memory location, no need to write back.
             if (funcType && funcType->getParamCount() > i &&
-                as<IRConstRefType>(funcType->getParamType(i)))
+                as<IRBorrowInParamType>(funcType->getParamType(i)))
                 continue;
             // If the buffer location is immutable, don't write back.
             if (isPointerToImmutableLocation(root))
diff --git a/source/slang/slang-ir-transform-params-to-constref.cpp b/source/slang/slang-ir-transform-params-to-constref.cpp
index d34b3d25b..b08c9b17f 100644
--- a/source/slang/slang-ir-transform-params-to-constref.cpp
+++ b/source/slang/slang-ir-transform-params-to-constref.cpp
@@ -143,7 +143,7 @@ struct TransformParamsToConstRefContext
         switch (root->getDataType()->getOp())
         {
         case kIROp_ConstantBufferType:
-        case kIROp_ConstRefType:
+        case kIROp_BorrowInParamType:
         case kIROp_ParameterBlockType:
             return addr;
         default:
@@ -270,17 +270,17 @@ struct TransformParamsToConstRefContext
         {
             if (shouldTransformParam(param))
             {
-                // Our goal here is to transform `in T` parameters to const-ref.
+                // Our goal here is to transform `in T` parameters to `borrow in T`.
                 // We are selective about what we will transform for a few reasons:
                 // 1. no reason to transform simple primitives like `int`.
                 // 2. not every type makes sense as constref. For example, `ParameterBlock`.
-                // 3. constref is not 100% stable, so we need to be selective on what we let
-                //    transform into constref.
+                // 3. `borrow in` is not 100% stable, so we need to be selective on what we let
+                //    transform into `borrow in`.
                 //
                 // This allows us to pass the address of variables directly into a function,
                 // giving us the choice to remove copies into a parameter.
                 auto paramType = param->getDataType();
-                auto constRefType = builder.getConstRefType(paramType, AddressSpace::Generic);
+                auto constRefType = builder.getBorrowInParamType(paramType, AddressSpace::Generic);
                 param->setFullType(constRefType);
 
                 changed = true;
diff --git a/source/slang/slang-ir-translate-global-varying-var.cpp b/source/slang/slang-ir-translate-global-varying-var.cpp
index 6b8c4842b..1a0f3dd9e 100644
--- a/source/slang/slang-ir-translate-global-varying-var.cpp
+++ b/source/slang/slang-ir-translate-global-varying-var.cpp
@@ -214,7 +214,7 @@ struct GlobalVarTranslationContext
 
                 // Emit a new param here to represent the global input var.
                 auto inputParam =
-                    builder.emitParam(builder.getConstRefType(inputType, AddressSpace::Input));
+                    builder.emitParam(builder.getBorrowInParamType(inputType, AddressSpace::Input));
 
                 // Copy the global input vars original decorations onto the new param.
                 // We need to do this to ensure that we can do things like get system
diff --git a/source/slang/slang-ir-use-uninitialized-values.cpp b/source/slang/slang-ir-use-uninitialized-values.cpp
index daa667a0a..200f29d1b 100644
--- a/source/slang/slang-ir-use-uninitialized-values.cpp
+++ b/source/slang/slang-ir-use-uninitialized-values.cpp
@@ -54,7 +54,7 @@ enum ParameterCheckType
 static ParameterCheckType isPotentiallyUnintended(IRParam* param, Stage stage, int index)
 {
     IRType* type = param->getFullType();
-    if (auto out = as<IROutType>(param->getFullType()))
+    if (auto out = as<IROutParamType>(param->getFullType()))
     {
         // Don't check `out Vertices<T>` or `out Indices<T>` parameters
         // in mesh shaders.
@@ -75,7 +75,7 @@ static ParameterCheckType isPotentiallyUnintended(IRParam* param, Stage stage, i
 
         return AsOut;
     }
-    else if (auto inout = as<IRInOutType>(type))
+    else if (auto inout = as<IRBorrowInOutParamType>(type))
     {
         // TODO: some way to check if the method
         // is actually used for autodiff
@@ -263,7 +263,10 @@ static InstructionUsageType getCallUsageType(IRCall* call, IRInst* inst)
     // Consider it as a store if its passed
     // as an out/inout/ref parameter
     auto type = unwrapAttributedType(ftype->getParamType(index));
-    return (as<IROutType>(type) || as<IRInOutType>(type) || as<IRRefType>(type)) ? Store : Load;
+    return (as<IROutParamType>(type) || as<IRBorrowInOutParamType>(type) ||
+            as<IRRefParamType>(type))
+               ? Store
+               : Load;
 }
 
 static InstructionUsageType getInstructionUsageType(IRInst* user, IRInst* inst)
diff --git a/source/slang/slang-ir-util.cpp b/source/slang/slang-ir-util.cpp
index 12e37f42a..9bec464dc 100644
--- a/source/slang/slang-ir-util.cpp
+++ b/source/slang/slang-ir-util.cpp
@@ -312,8 +312,8 @@ bool isWrapperType(IRInst* inst)
     case kIROp_VectorType:
     case kIROp_MatrixType:
     case kIROp_PtrType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
     case kIROp_HLSLStructuredBufferType:
     case kIROp_HLSLRWStructuredBufferType:
     case kIROp_HLSLRasterizerOrderedStructuredBufferType:
@@ -1021,11 +1021,11 @@ bool isPtrLikeOrHandleType(IRInst* type)
     case kIROp_ComPtrType:
     case kIROp_RawPointerType:
     case kIROp_RTTIPointerType:
-    case kIROp_OutType:
-    case kIROp_InOutType:
+    case kIROp_OutParamType:
+    case kIROp_BorrowInOutParamType:
     case kIROp_PtrType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
     case kIROp_GLSLShaderStorageBufferType:
         return true;
     }
@@ -1358,7 +1358,7 @@ bool areCallArgumentsSideEffectFree(IRCall* call, SideEffectAnalysisOptions opti
                         if (!funcType)
                             return false;
                         if (funcType->getParamCount() > i &&
-                            as<IROutType>(funcType->getParamType(i)))
+                            as<IROutParamType>(funcType->getParamType(i)))
                             continue;
 
                         // We are an argument to an inout parameter.
@@ -1762,7 +1762,7 @@ IRPtrTypeBase* isMutablePointerType(IRInst* inst)
 {
     switch (inst->getOp())
     {
-    case kIROp_ConstRefType:
+    case kIROp_BorrowInParamType:
         return nullptr;
     default:
         return asRelevantPtrType(inst);
diff --git a/source/slang/slang-ir-validate.cpp b/source/slang/slang-ir-validate.cpp
index e7bb7b548..b14a76784 100644
--- a/source/slang/slang-ir-validate.cpp
+++ b/source/slang/slang-ir-validate.cpp
@@ -488,7 +488,7 @@ static bool isValidAtomicDest(bool skipFuncParamValidation, IRInst* dst)
     if (auto param = as<IRParam>(dst))
     {
         auto paramType = param->getDataType();
-        if (auto outType = as<IROutTypeBase>(paramType))
+        if (auto outType = as<IROutParamTypeBase>(paramType))
         {
             if (outType->getAddressSpace() == AddressSpace::GroupShared)
             {
diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp
index e54238a9c..9ec8a2c8b 100644
--- a/source/slang/slang-ir.cpp
+++ b/source/slang/slang-ir.cpp
@@ -2937,25 +2937,26 @@ IRPtrType* IRBuilder::getPtrType(IRType* valueType)
     return (IRPtrType*)getPtrType(kIROp_PtrType, valueType);
 }
 
-IROutType* IRBuilder::getOutType(IRType* valueType)
+IROutParamType* IRBuilder::getOutParamType(IRType* valueType)
 {
-    return (IROutType*)getPtrType(kIROp_OutType, valueType);
+    return (IROutParamType*)getPtrType(kIROp_OutParamType, valueType);
 }
 
-IRInOutType* IRBuilder::getInOutType(IRType* valueType)
+IRBorrowInOutParamType* IRBuilder::getBorrowInOutParamType(IRType* valueType)
 {
-    return (IRInOutType*)getPtrType(kIROp_InOutType, valueType);
+    return (IRBorrowInOutParamType*)getPtrType(kIROp_BorrowInOutParamType, valueType);
 }
 
-IRRefType* IRBuilder::getRefType(IRType* valueType, AddressSpace addrSpace)
+IRRefParamType* IRBuilder::getRefParamType(IRType* valueType, AddressSpace addrSpace)
 {
-    return (IRRefType*)getPtrType(kIROp_RefType, valueType, AccessQualifier::ReadWrite, addrSpace);
+    return (IRRefParamType*)
+        getPtrType(kIROp_RefParamType, valueType, AccessQualifier::ReadWrite, addrSpace);
 }
 
-IRConstRefType* IRBuilder::getConstRefType(IRType* valueType, AddressSpace addrSpace)
+IRBorrowInParamType* IRBuilder::getBorrowInParamType(IRType* valueType, AddressSpace addrSpace)
 {
-    return (
-        IRConstRefType*)getPtrType(kIROp_ConstRefType, valueType, AccessQualifier::Read, addrSpace);
+    return (IRBorrowInParamType*)
+        getPtrType(kIROp_BorrowInParamType, valueType, AccessQualifier::Read, addrSpace);
 }
 
 IRSPIRVLiteralType* IRBuilder::getSPIRVLiteralType(IRType* type)
@@ -4025,11 +4026,11 @@ IRInst* IRBuilder::emitDefaultConstruct(IRType* type, bool fallback)
     case kIROp_StringType:
         return getStringValue(UnownedStringSlice());
     case kIROp_PtrType:
-    case kIROp_InOutType:
-    case kIROp_OutType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_OutParamType:
     case kIROp_RawPointerType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
     case kIROp_ComPtrType:
     case kIROp_NativePtrType:
     case kIROp_NativeStringType:
@@ -4182,11 +4183,11 @@ static TypeCastStyle _getTypeStyleId(IRType* type)
     case kIROp_BoolType:
         return TypeCastStyle::Bool;
     case kIROp_PtrType:
-    case kIROp_InOutType:
-    case kIROp_OutType:
+    case kIROp_BorrowInOutParamType:
+    case kIROp_OutParamType:
     case kIROp_RawPointerType:
-    case kIROp_RefType:
-    case kIROp_ConstRefType:
+    case kIROp_RefParamType:
+    case kIROp_BorrowInParamType:
         return TypeCastStyle::Ptr;
     case kIROp_EnumType:
         return TypeCastStyle::Enum;
diff --git a/source/slang/slang-language-server-inlay-hints.cpp b/source/slang/slang-language-server-inlay-hints.cpp
index 982b9f910..89c6bd0bc 100644
--- a/source/slang/slang-language-server-inlay-hints.cpp
+++ b/source/slang/slang-language-server-inlay-hints.cpp
@@ -76,7 +76,7 @@ List<LanguageServerProtocol::InlayHint> getInlayHints(
                             lblSb << "inout ";
                         else if (param->hasModifier<RefModifier>())
                             lblSb << "ref ";
-                        else if (param->hasModifier<ConstRefModifier>())
+                        else if (param->hasModifier<BorrowModifier>())
                             lblSb << "constref ";
                         lblSb << name->text;
                         lblSb << ":";
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index 5d83a351f..12545ad0d 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -387,7 +387,7 @@ struct ImplicitCastLValueInfo : ExtendedValueInfo
     LoweredValInfo base;
 
     // The type of the lvalue (inout, out, ref, etc.)
-    ParameterDirection lValueType;
+    ParamPassingMode lValueType;
 };
 
 LoweredValInfo LoweredValInfo::boundMember(BoundMemberInfo* boundMemberInfo)
@@ -2524,8 +2524,9 @@ void addVarDecorations(IRGenContext* context, IRInst* inst, Decl* decl)
         }
         // TODO: what are other modifiers we need to propagate through?
     }
-    if (auto t =
-            composeGetters<IRMeshOutputType>(inst->getFullType(), &IROutTypeBase::getValueType))
+    if (auto t = composeGetters<IRMeshOutputType>(
+            inst->getFullType(),
+            &IROutParamTypeBase::getValueType))
     {
         IROp op;
         switch (t->getOp())
@@ -2774,17 +2775,17 @@ static void applyOutArgumentFixups(IRGenContext* context, List<OutArgumentFixup>
 /// Add one argument value to the argument list for a call being constructed
 void addArg(
     IRGenContext* context,
-    List<IRInst*>* ioArgs,             //< The argument list being built
-    List<OutArgumentFixup>* ioFixups,  //< "Fixup" logic to apply for `out` or `inout` arguments
-    LoweredValInfo argVal,             //< The lowered value of the argument to add
-    IRType* paramType,                 //< The type of the corresponding parameter
-    ParameterDirection paramDirection, //< The direction of the parameter (`in`, `out`, etc.)
-    Type* argType,                     //< The AST-level type of the argument
-    SourceLoc loc)                     //< A location to use if we need to report an error
+    List<IRInst*>* ioArgs,            //< The argument list being built
+    List<OutArgumentFixup>* ioFixups, //< "Fixup" logic to apply for `out` or `inout` arguments
+    LoweredValInfo argVal,            //< The lowered value of the argument to add
+    IRType* paramType,                //< The type of the corresponding parameter
+    ParamPassingMode paramDirection,  //< The direction of the parameter (`in`, `out`, etc.)
+    Type* argType,                    //< The AST-level type of the argument
+    SourceLoc loc)                    //< A location to use if we need to report an error
 {
     switch (paramDirection)
     {
-    case kParameterDirection_Ref:
+    case ParamPassingMode::Ref:
         {
             // According to our "calling convention" we need to
             // pass a pointer into the callee. Unlike the case for
@@ -2808,9 +2809,9 @@ void addArg(
         }
         break;
 
-    case kParameterDirection_Out:
-    case kParameterDirection_InOut:
-    case kParameterDirection_ConstRef:
+    case ParamPassingMode::Out:
+    case ParamPassingMode::BorrowInOut:
+    case ParamPassingMode::BorrowIn:
         {
             // According to our "calling convention" we need to
             // pass a pointer into the callee.
@@ -2838,7 +2839,7 @@ void addArg(
                     paramType = lowerType(context, argType);
                 }
 #if 0
-                if (auto refType = as<IRConstRefType>(paramType))
+                if (auto refType = as<IRBorrowInParamType>(paramType))
                 {
                     paramType = refType->getValueType();
                     argVal = LoweredValInfo::simple(
@@ -2853,8 +2854,8 @@ void addArg(
                 // in the argument, which we accomplish by assigning
                 // from the l-value to our temp.
                 //
-                if (paramDirection == kParameterDirection_InOut ||
-                    paramDirection == kParameterDirection_ConstRef)
+                if (paramDirection == ParamPassingMode::BorrowInOut ||
+                    paramDirection == ParamPassingMode::BorrowIn)
                 {
                     assign(context, tempVar, argVal);
                 }
@@ -2868,7 +2869,7 @@ void addArg(
                 // Finally, after the call we will need
                 // to copy in the other direction: from our
                 // temp back to the original l-value.
-                if (paramDirection != kParameterDirection_ConstRef)
+                if (paramDirection != ParamPassingMode::BorrowIn)
                 {
                     OutArgumentFixup fixup;
                     fixup.src = tempVar;
@@ -2900,17 +2901,17 @@ void addArg(
 void addCallArgsForParam(
     IRGenContext* context,
     IRType* paramType,
-    ParameterDirection paramDirection,
+    ParamPassingMode paramDirection,
     Expr* argExpr,
     List<IRInst*>* ioArgs,
     List<OutArgumentFixup>* ioFixups)
 {
     switch (paramDirection)
     {
-    case kParameterDirection_Ref:
-    case kParameterDirection_ConstRef:
-    case kParameterDirection_Out:
-    case kParameterDirection_InOut:
+    case ParamPassingMode::Ref:
+    case ParamPassingMode::BorrowIn:
+    case ParamPassingMode::Out:
+    case ParamPassingMode::BorrowInOut:
         {
             LoweredValInfo loweredArg = lowerLValueExpr(context, argExpr);
             addArg(
@@ -2938,38 +2939,38 @@ void addCallArgsForParam(
 //
 
 /// Compute the direction for a parameter based on its declaration
-ParameterDirection getParameterDirection(VarDeclBase* paramDecl)
+ParamPassingMode getParameterDirection(VarDeclBase* paramDecl)
 {
     if (paramDecl->hasModifier<RefModifier>())
     {
-        return kParameterDirection_Ref;
+        return ParamPassingMode::Ref;
     }
-    if (paramDecl->hasModifier<ConstRefModifier>() || paramDecl->hasModifier<HLSLPayloadModifier>())
+    if (paramDecl->hasModifier<BorrowModifier>() || paramDecl->hasModifier<HLSLPayloadModifier>())
     {
         // The payload types are a groupshared variable, and we really don't
         // want to copy that into registers in every invocation on platforms
         // where this matters, so treat them as by-reference here.
 
-        return kParameterDirection_ConstRef;
+        return ParamPassingMode::BorrowIn;
     }
     if (paramDecl->hasModifier<InOutModifier>())
     {
         // The AST specified `inout`:
-        return kParameterDirection_InOut;
+        return ParamPassingMode::BorrowInOut;
     }
     if (paramDecl->hasModifier<OutModifier>())
     {
         // We saw an `out` modifier, so now we need
         // to check if there was a paired `in`.
         if (paramDecl->hasModifier<InModifier>())
-            return kParameterDirection_InOut;
+            return ParamPassingMode::BorrowInOut;
         else
-            return kParameterDirection_Out;
+            return ParamPassingMode::Out;
     }
     else
     {
         // No direction modifier, or just `in`:
-        return kParameterDirection_In;
+        return ParamPassingMode::In;
     }
 }
 
@@ -2978,22 +2979,22 @@ ParameterDirection getParameterDirection(VarDeclBase* paramDecl)
 /// If the given declaration doesn't care about the direction of a `this` parameter, then
 /// it will return the provided `defaultDirection` instead.
 ///
-ParameterDirection getThisParamDirection(Decl* parentDecl, ParameterDirection defaultDirection)
+ParamPassingMode getThisParamDirection(Decl* parentDecl, ParamPassingMode defaultDirection)
 {
     auto parentParent = getParentAggTypeDecl(parentDecl);
 
     // The `this` parameter for a `class` is always `in`.
     if (as<ClassDecl>(parentParent))
     {
-        return kParameterDirection_In;
+        return ParamPassingMode::In;
     }
 
     if (parentParent && parentParent->findModifier<NonCopyableTypeAttribute>())
     {
         if (parentDecl->hasModifier<MutatingAttribute>())
-            return kParameterDirection_Ref;
+            return ParamPassingMode::Ref;
         else
-            return kParameterDirection_ConstRef;
+            return ParamPassingMode::BorrowIn;
     }
 
     // Applications can opt in to a mutable `this` parameter,
@@ -3002,15 +3003,15 @@ ParameterDirection getThisParamDirection(Decl* parentDecl, ParameterDirection de
     //
     if (parentDecl->hasModifier<MutatingAttribute>())
     {
-        return kParameterDirection_InOut;
+        return ParamPassingMode::BorrowInOut;
     }
     else if (parentDecl->hasModifier<ConstRefAttribute>())
     {
-        return kParameterDirection_ConstRef;
+        return ParamPassingMode::BorrowIn;
     }
     else if (parentDecl->hasModifier<RefAttribute>())
     {
-        return kParameterDirection_Ref;
+        return ParamPassingMode::Ref;
     }
 
     // A `set` accessor on a property or subscript declaration
@@ -3019,11 +3020,11 @@ ParameterDirection getThisParamDirection(Decl* parentDecl, ParameterDirection de
     //
     if (parentDecl->hasModifier<NonmutatingAttribute>())
     {
-        return kParameterDirection_In;
+        return ParamPassingMode::In;
     }
     else if (as<SetterDecl>(parentDecl))
     {
-        return kParameterDirection_InOut;
+        return ParamPassingMode::BorrowInOut;
     }
 
     // Declarations that represent abstract storage (a property
@@ -3050,7 +3051,7 @@ ParameterDirection getThisParamDirection(Decl* parentDecl, ParameterDirection de
 
     // For now we make any `this` parameter default to `in`.
     //
-    return kParameterDirection_In;
+    return ParamPassingMode::In;
 }
 
 DeclRef<Decl> createDefaultSpecializedDeclRefImpl(
@@ -3203,10 +3204,10 @@ struct IRLoweringParameterInfo
     Type* type = nullptr;
 
     // The direction (`in` vs `out` vs `in out`)
-    ParameterDirection direction;
+    ParamPassingMode direction;
 
     // The direction declared in user code.
-    ParameterDirection declaredDirection = ParameterDirection::kParameterDirection_In;
+    ParamPassingMode declaredDirection = ParamPassingMode::In;
 
     // The variable/parameter declaration for
     // this parameter (if any)
@@ -3272,7 +3273,7 @@ ParameterListCollectMode getModeForCollectingParentParameters(Decl* decl, Contai
 // When dealing with a member function, we need to be able to add the `this`
 // parameter for the enclosing type:
 //
-void addThisParameter(ParameterDirection direction, Type* type, ParameterLists* ioParameterLists)
+void addThisParameter(ParamPassingMode direction, Type* type, ParameterLists* ioParameterLists)
 {
     IRLoweringParameterInfo info;
     info.type = type;
@@ -3291,7 +3292,7 @@ void maybeAddReturnDestinationParam(ParameterLists* ioParameterLists, Type* resu
         IRLoweringParameterInfo info;
         info.type = resultType;
         info.decl = nullptr;
-        info.direction = kParameterDirection_Ref;
+        info.direction = ParamPassingMode::Ref;
         info.declaredDirection = info.direction;
         info.isReturnDestination = true;
         ioParameterLists->params.add(info);
@@ -3300,13 +3301,13 @@ void maybeAddReturnDestinationParam(ParameterLists* ioParameterLists, Type* resu
 
 void makeVaryingInputParamConstRef(IRLoweringParameterInfo& paramInfo)
 {
-    if (paramInfo.direction != kParameterDirection_In)
+    if (paramInfo.direction != ParamPassingMode::In)
         return;
     if (paramInfo.decl->findModifier<HLSLUniformModifier>())
         return;
     if (as<HLSLPatchType>(paramInfo.type))
         return;
-    paramInfo.direction = kParameterDirection_ConstRef;
+    paramInfo.direction = ParamPassingMode::BorrowIn;
 }
 //
 // And here is our function that will do the recursive walk:
@@ -3315,7 +3316,7 @@ void collectParameterLists(
     DeclRef<Decl> const& declRef,
     ParameterLists* ioParameterLists,
     ParameterListCollectMode mode,
-    ParameterDirection thisParamDirection)
+    ParamPassingMode thisParamDirection)
 {
     // Don't collect any parameters beyond certain decls.
     if (as<InterfaceDefaultImplDecl>(declRef) || as<AggTypeDeclBase>(declRef))
@@ -3337,7 +3338,7 @@ void collectParameterLists(
         if (innerMode < mode)
             innerMode = mode;
 
-        ParameterDirection innerThisParamDirection =
+        ParamPassingMode innerThisParamDirection =
             getThisParamDirection(declRef.getDecl(), thisParamDirection);
 
 
@@ -3368,7 +3369,7 @@ void collectParameterLists(
                 else if (auto bwdDerivDeclRef = declRef.as<BackwardDerivativeRequirementDecl>())
                 {
                     thisType = bwdDerivDeclRef.getDecl()->diffThisType;
-                    innerThisParamDirection = kParameterDirection_InOut;
+                    innerThisParamDirection = ParamPassingMode::BorrowInOut;
                 }
 
                 addThisParameter(innerThisParamDirection, thisType, ioParameterLists);
@@ -3383,10 +3384,10 @@ void collectParameterLists(
     {
         // We need a special case here when lowering the varying parameters of an entrypoint
         // function. Due to the existence of `EvaluateAttributeAtSample` and friends, we need to
-        // always lower the varying inputs as `__constref` parameters so we can pass pointers to
+        // always lower the varying inputs as `borrow in` parameters so we can pass pointers to
         // these intrinsics.
         // This means that although these parameters are declared as "in" parameters in the source,
-        // we will actually treat them as __constref parameters when lowering to IR. A complication
+        // we will actually treat them as `borrow in` parameters when lowering to IR. A complication
         // result from this is that if the original source code actually modifies the input
         // parameter we still need to create a local var to hold the modified value. In the future
         // when we are able to update our language spec to always assume input parameters are
@@ -3467,7 +3468,7 @@ void _lowerFuncDeclBaseTypeInfo(
         declRef,
         &parameterLists,
         kParameterListCollectMode_Default,
-        kParameterDirection_In);
+        ParamPassingMode::In);
 
     auto& paramTypes = outInfo.paramTypes;
 
@@ -3477,7 +3478,7 @@ void _lowerFuncDeclBaseTypeInfo(
 
         switch (paramInfo.direction)
         {
-        case kParameterDirection_In:
+        case ParamPassingMode::In:
             // Simple case of a by-value input parameter.
             break;
 
@@ -3485,17 +3486,17 @@ void _lowerFuncDeclBaseTypeInfo(
         // then we will represent it with a pointer type in
         // the IR, but we will use a specialized pointer
         // type that encodes the parameter direction information.
-        case kParameterDirection_Out:
-            irParamType = builder->getOutType(irParamType);
+        case ParamPassingMode::Out:
+            irParamType = builder->getOutParamType(irParamType);
             break;
-        case kParameterDirection_InOut:
-            irParamType = builder->getInOutType(irParamType);
+        case ParamPassingMode::BorrowInOut:
+            irParamType = builder->getBorrowInOutParamType(irParamType);
             break;
-        case kParameterDirection_Ref:
-            irParamType = builder->getRefType(irParamType, AddressSpace::Generic);
+        case ParamPassingMode::Ref:
+            irParamType = builder->getRefParamType(irParamType, AddressSpace::Generic);
             break;
-        case kParameterDirection_ConstRef:
-            irParamType = builder->getConstRefType(irParamType, AddressSpace::Generic);
+        case ParamPassingMode::BorrowIn:
+            irParamType = builder->getBorrowInParamType(irParamType, AddressSpace::Generic);
             break;
         default:
             SLANG_UNEXPECTED("unknown parameter direction");
@@ -3753,7 +3754,7 @@ struct ExprLoweringContext
         InvokeExpr* expr,
         Index argIndex,
         IRType* paramType,
-        ParameterDirection paramDirection,
+        ParamPassingMode paramDirection,
         DeclRef<ParamDecl> paramDeclRef,
         List<IRInst*>* ioArgs,
         List<OutArgumentFixup>* ioFixups)
@@ -4073,7 +4074,7 @@ struct ExprLoweringContext
                 addCallArgsForParam(
                     context,
                     irThisType,
-                    getThisParamDirection(funcDeclRef.getDecl(), kParameterDirection_In),
+                    getThisParamDirection(funcDeclRef.getDecl(), ParamPassingMode::In),
                     baseExpr,
                     &irArgs,
                     &argFixups);
@@ -5851,9 +5852,9 @@ struct LValueExprLoweringVisitor : ExprLoweringVisitorBase<LValueExprLoweringVis
         RefPtr<ImplicitCastLValueInfo> lValueInfo = new ImplicitCastLValueInfo();
         lValueInfo->type = irType;
         lValueInfo->base = loweredArg;
-        lValueInfo->lValueType = kParameterDirection_InOut;
+        lValueInfo->lValueType = ParamPassingMode::BorrowInOut;
         if (as<OutImplicitCastExpr>(expr))
-            lValueInfo->lValueType = kParameterDirection_Out;
+            lValueInfo->lValueType = ParamPassingMode::Out;
         context->shared->extValues.add(lValueInfo);
         return LoweredValInfo::implicitCastedLValue(lValueInfo);
     }
@@ -7809,7 +7810,7 @@ LoweredValInfo tryGetAddress(
             if (baseAddr.flavor == LoweredValInfo::Flavor::Ptr)
             {
                 IRInst* result = nullptr;
-                if (info->lValueType == kParameterDirection_InOut)
+                if (info->lValueType == ParamPassingMode::BorrowInOut)
                     result = context->irBuilder->emitInOutImplicitCast(
                         context->irBuilder->getPtrType(info->type),
                         baseAddr.val);
@@ -10940,8 +10941,8 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
                         if (paramInfo.isReturnDestination)
                             subContext->returnDestination = paramVal;
 
-                        if (paramInfo.declaredDirection == kParameterDirection_In &&
-                            paramInfo.direction == kParameterDirection_ConstRef)
+                        if (paramInfo.declaredDirection == ParamPassingMode::In &&
+                            paramInfo.direction == ParamPassingMode::BorrowIn)
                         {
                             // If the parameter is originally declared as "in", but we are
                             // lowering it as constref for any reason (e.g. it is a varying input),
@@ -10967,7 +10968,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
                     }
                     break;
 
-                case kParameterDirection_In:
+                case ParamPassingMode::In:
                     {
                         // Simple case of a by-value input parameter.
                         //
diff --git a/source/slang/slang-mangle.cpp b/source/slang/slang-mangle.cpp
index d96b5591b..ee2f5a347 100644
--- a/source/slang/slang-mangle.cpp
+++ b/source/slang/slang-mangle.cpp
@@ -644,27 +644,27 @@ void emitQualifiedName(ManglingContext* context, DeclRef<Decl> declRef, bool inc
             // parameter modifier makes big difference in the spirv code generation, for example
             // "out"/"inout" parameter will be passed by pointer. Therefore, we need to
             // distinguish them in the mangled name to avoid name collision.
-            ParameterDirection paramDirection = getParameterDirection(paramDeclRef.getDecl());
+            ParamPassingMode paramDirection = getParameterDirection(paramDeclRef.getDecl());
             switch (paramDirection)
             {
-            case kParameterDirection_Ref:
+            case ParamPassingMode::Ref:
                 emitRaw(context, "r_");
                 break;
-            case kParameterDirection_ConstRef:
+            case ParamPassingMode::BorrowIn:
                 emitRaw(context, "c_");
                 break;
-            case kParameterDirection_Out:
+            case ParamPassingMode::Out:
                 emitRaw(context, "o_");
                 break;
-            case kParameterDirection_InOut:
+            case ParamPassingMode::BorrowInOut:
                 emitRaw(context, "io_");
                 break;
-            case kParameterDirection_In:
+            case ParamPassingMode::In:
                 emitRaw(context, "i_");
                 break;
             default:
                 StringBuilder errMsg;
-                errMsg << "Unknown parameter direction: " << paramDirection;
+                errMsg << "Unknown parameter direction: " << int(paramDirection);
                 SLANG_ABORT_COMPILATION(errMsg.toString().begin());
                 break;
             }
diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp
index c225ff4ee..dde783ce8 100644
--- a/source/slang/slang-parser.cpp
+++ b/source/slang/slang-parser.cpp
@@ -9589,7 +9589,7 @@ static const SyntaxParseInfo g_parseSyntaxEntries[] = {
     _makeParseModifier("out", getSyntaxClass<OutModifier>()),
     _makeParseModifier("inout", getSyntaxClass<InOutModifier>()),
     _makeParseModifier("__ref", getSyntaxClass<RefModifier>()),
-    _makeParseModifier("__constref", getSyntaxClass<ConstRefModifier>()),
+    _makeParseModifier("__constref", getSyntaxClass<BorrowModifier>()),
     _makeParseModifier("const", getSyntaxClass<ConstModifier>()),
     _makeParseModifier("__builtin", getSyntaxClass<BuiltinModifier>()),
     _makeParseModifier("highp", getSyntaxClass<GLSLPrecisionModifier>()),
diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp
index b991a0caf..2498c1226 100644
--- a/source/slang/slang-syntax.cpp
+++ b/source/slang/slang-syntax.cpp
@@ -934,7 +934,7 @@ FuncType* getFuncType(ASTBuilder* astBuilder, DeclRef<CallableDecl> const& declR
         {
             paramType = astBuilder->getRefParamType(paramType);
         }
-        else if (paramDecl->findModifier<ConstRefModifier>())
+        else if (paramDecl->findModifier<BorrowModifier>())
         {
             paramType = astBuilder->getConstRefParamType(paramType);
         }
@@ -942,11 +942,11 @@ FuncType* getFuncType(ASTBuilder* astBuilder, DeclRef<CallableDecl> const& declR
         {
             if (paramDecl->findModifier<InOutModifier>() || paramDecl->findModifier<InModifier>())
             {
-                paramType = astBuilder->getInOutType(paramType);
+                paramType = astBuilder->getBorrowInOutParamType(paramType);
             }
             else
             {
-                paramType = astBuilder->getOutType(paramType);
+                paramType = astBuilder->getOutParamType(paramType);
             }
         }
         paramTypes.add(paramType);
diff --git a/source/slang/slang-syntax.h b/source/slang/slang-syntax.h
index e7a82592c..640fa8fcd 100644
--- a/source/slang/slang-syntax.h
+++ b/source/slang/slang-syntax.h
@@ -238,7 +238,7 @@ SubstitutionSet makeSubstitutionFromIncompleteSet(
 
 Val::OperandView<Val> findInnerMostGenericArgs(SubstitutionSet subst);
 
-ParameterDirection getParameterDirection(VarDeclBase* varDecl);
+ParamPassingMode getParameterDirection(VarDeclBase* varDecl);
 
 inline Type* getTagType(ASTBuilder* astBuilder, DeclRef<EnumDecl> declRef)
 {
diff --git a/tests/diagnostics/const-ref-differentiable-param.slang b/tests/diagnostics/const-ref-differentiable-param.slang
index c345826e7..354744701 100644
--- a/tests/diagnostics/const-ref-differentiable-param.slang
+++ b/tests/diagnostics/const-ref-differentiable-param.slang
@@ -32,7 +32,7 @@ struct MyType2
     float compute1(float x) { return 0; }
 }
 
-// CHECK-DAG: {{.*}}(5): error 38034: cannot use '__constref' on a differentiable parameter.
+// CHECK-DAG: {{.*}}(5): error 38034: cannot use 'borrow in' on a differentiable parameter.
 // CHECK-NOT {{.*}}error
 // CHECK-DAG: {{.*}}(14): error 38034: cannot use '[constref]' on a differentiable member method of a differentiable type.
 // CHECK-NOT {{.*}}error