Type placeholder

[msa-combination]

Background

In C/C++ you can use the typedef syntax, in many DBMS there are the user defined data types.
C# needs a similar functionality to permit code being more expressive, readable and secure.

namespace DangerCode
{
    using ParamType1 = System.Int32;
    using ParamType2 = System.Int32;
    using ReturnType = System.Int32;

    public class Program
    {
        public static ReturnType Method(ParamType1 param1, ParamType2 param2)
        {
            return param1 + param2;
        }

        static void Main(string[] args)
        {
            ParamType1 param1 = 1;
            ParamType2 param2 = 2;

            ReturnType r1 = Method(param1, param2);
            ReturnType r2 = Method(param2, param1); // Dangerous and unsecure!!!
        }
    }
}

Proposal

This proposal is about the new keywork "placeholder" and this new syntax:

[public|private] placeholder <IdentifierName> for <Type>;

that permits to add a real new type based on other types on the project.

namespace SaferCode
{
    public placeholder ParamType1 for System.Int32;
    public placeholder ParamType2 for System.Int32;
    public placeholder ReturnType for System.Int32;

    public class Program
    {
        public static ReturnType Method(ParamType1 param1, ParamType2 param2)
        {
            return param1 + param2;
        }

        static void Main(string[] args)
        {
            ParamType1 param1 = 1;
            ParamType2 param2 = 2;

            ReturnType r1 = Method(param1, param2);
            ReturnType r2 = Method(param2, param1); // Compiler error!!! 
        }
    }
}

Visibility

• private: it is not possible to use the new user defined data type outside
• public: it is possible to use the new user defined data type outside

Scope

The scopes of the defined user type will be: global, namespace or class
based on the position of the declaration

[Joe4evr]

Sounds like you want semantic types, which you could do with a source generator. Have it trigger on an attribute like

[assembly: SemanticType("ParamType1", typeof(int), Visibility.Public)]
[assembly: SemanticType("ParamType2", typeof(int), Visibility.Public)]
[assembly: SemanticType("ReturnType", typeof(int), Visibility.Public)]

public class Program
{
    // With the generated types, attempting to call this method with the arguments reversed will error like you want.
    public static ReturnType Method(ParamType1 param1, ParamType2 param2)
    {
        return new ReturnType(param1.Value + param2.Value);
    }
}

[Unknown6656]

Why not extend the existing using x = y; syntax to be used in classes or scopes and made public/private?
I'd rather not see a new keyword (placeholder) to be added.

[huoyaoyuan]

Because they are still considered the same type, which is not ideal.

[HaloFour]

I don't think placeholder does any better an conveying that they're not the same type.

IMO, these are use cases best solved by single-case unions or records:

public struct record ParamType1(string value);
public struct record ParamType2(string value);

That gives you proper CLR types wrapping the underlying value that can be used in signatures and such simple structs are also very easily inlined by the JIT.

[Unknown6656]

@huoyaoyuan

Because they are still considered the same type, which is not ideal.

I can understand this requirement for name-based identity/equality instead of structural equality (as is the case with using x = y;).
I'd then suggest the following alternatives to using x = y;:

1. public sealed record x(y value); or public struct record x(y value); (as @HaloFour suggested)
2. Some kind of new syntax á la using class x = y; or using struct x = y;

[HaloFour]

I believe that this is also something that the "roles" discussion intends to solve: #1711

[msa-combination]

The proposal is more about the system types (int, string, decimal, ...) than about classes, structs, ...

[msa-combination]

It will really useful for EF too (and Linq in general).
No more worries for bugs like Users.UserId == Companies.CompanyId instead of Users.CompanyId == Companies.CompanyId

[theunrepentantgeek]

You can achieve this today - in fact you've been able to do so since C# 1.0 by writing a semantic type.

The recent support for record types makes the declaration trivial.

Also, a typedef (or placeholder) has nowhere for behaviour - and there's always behaviour. Construction, validation, canonical forms, comparison rules, formatting, the list goes on.