[SUGGESTION] Treat a keyword as an identifier

[msadeqhe]

Preface

I suggest to use "keyword"$ syntax to treat keywords as identifiers in Cpp2.

Suggestion Detail

Some identifiers in Cpp2 are keywords in Cpp1 such as and, or, etc. These identifiers aren't valid identifiers in Cpp1. Therefore Cpp2 appends cpp2_ prefix to these identifiers during code generation for Cpp1 as discussed in this issue. For example identifiers and, or, etc in Cpp2 will respectively become identifiers cpp2_and, cpp2_or, etc in generated Cpp1 code.

On the other hand, some keywords in Cpp2 aren't keywords in Cpp1 such as type, next, etc. These keywords are valid identifiers in Cpp1. Therefore it's not possible to use such identifiers in Cpp2 when dealing with Cpp1 API:

// ERROR! `type` is a keyword, whereas it's an identifier in Cpp1.
v0: = type.name();

// ERROR! `next` is a keyword, whereas it's an identifier in Cpp1.
while next < 10 next next++ {
    //: statements...
}

I suggest to use a syntax such as "keyword"$ to access identifiers from Cpp1 API in which they are keywords in Cpp2:

// OK. `type` is an identifier.
v0: = "type"$.name();

// OK. `next` is an identifier.
while "next"$ < 10 next "next"$++ {
    //: statements...
}

I think syntax "keyword"$ is good enough because Cpp2 will have similar syntax for reflections and code generations as described in this page of Wiki. And semantically this is related to them.

Your Questions

Will your feature suggestion eliminate X% of security vulnerabilities of a given kind in current C++ code?

No.

Will your feature suggestion automate or eliminate X% of current C++ guidance literature?

No.

Considered Alternatives

I considered to use syntax @keyword but it would resemble meta-class functions. Another possible syntax is @"keyword", which doesn't resemble meta-class functions in addition to its difference from capture syntax.

Also we can use a prefix such as cpp1_. For example:

// OK. `cpp1_type` will become `type` in Cpp1.
v0: = cpp1_type.name();

// OK. `cpp1_next` will become `next` in Cpp1.
while cpp1_next < 10 next cpp1_next++ {
    //: statements...
}

In this way, cpp1_ prefix in addition to cpp2_ prefix should be reserved for Cpp2 compiler, and user-defined identifiers with those prefixes shouldn't be allowed.

By the way, treating a keyword as an identifier, isn't frequency needed to dedicate a new symbol to it.

EDIT 1: keyword<> is another alternative solution as described in this comment.

[JohelEGP]

Therefore it's not possible to use such identifiers in Cpp2 when dealing with Cpp1 API

I've actually found the Cpp2-specific keywords to be contextual, except for the <cstdint> shorthands (e.g., i8), and inspect. So this works: https://godbolt.org/z/vYPf6MG6h.

int next = 0; // Cpp1.
f: () = {
    while next < 10 next next++ {
    //: statements...
    }
    while 10 < next next next++ {
    //: statements...
    }
}
main: () = {
    :(is) = { [[assert: (is)is(is)]] }(:() = {});
}

Including the :(is) = { [[assert: (is)is(is)]] }(:() = {});.

[msadeqhe]

You're right 😬, that's very nice but it doesn't work in every situation, for example:

type: type = {}

main: () = {
    variable: type = 0;
}

[JohelEGP]

I prefer cpp2_type
over "type"$
to lower to Cpp1 as type.

[msadeqhe]

Also Cpp2 may have more keywords during language evolution in the future, therefore keywords such as result in this issue are already valid identifiers in Cpp1.

[JohelEGP]

For variable: type = (), you want type to be a Cpp1 identifier. In this case, it clashes with Cpp2 syntax itself. It can be solved with an indirection: std::type_identity_t<type>: https://godbolt.org/z/TGoqsebrW.

[JohelEGP]

This are the sets of Cpp2-specific keywords:

{i8,       i16,       i32,       i64,       u8,
 u16,      u32,       u64,       i8_fast,   i16_fast,
 i32_fast, i64_fast,  u8_fast,   u16_fast,  u32_fast,
 u64_fast, i8_least,  i16_least, i32_least, i64_least,
 u8_least, u16_least, u32_least, u64_least, inspect});
{next, copy, move, forward, pre, post, final,
 in, 
 as, is, type, 
 assert, throws,  
 implicit, out,   
 inout});            

I can't come up with another example like #392 (comment)'s.
A simpler alternative for variable: type = ()
is qualifying type: variable: ::type = () https://godbolt.org/z/W3v48se5K.

[msadeqhe]

Thanks. It's a good idea to use helper type std::type_identity_t<type> or write the qualified name ::type. But ::type doesn't work for local types:

main: () = {
    type: type = {}
    variable: ::type = ();
}

[JohelEGP]

Well, the only reason to name it type in that case, would be for some Cpp1 library that reflects the identifer, or a wicked Cpp2 one.

[MichaelCook]

Perhaps a backslash prefix would be a little more readable.

v0: = \type.name();
while \next < 10 next \next++ {
    //: statements...
}```

[JohelEGP]

Makes me think if raw string literals could just be backslash-escaped (see #302).

[msadeqhe]

@MichaelCook, I like the idea to use backslash syntax \keyword.

Escape sequences in string literals start with a backslash to change the meaning of a character, why not just use it to change the meaning of a keyword and treat it as an identifier?

@JohelEGP, Good idea but in my opinion, raw (non-interpolated) string literals break the general capture syntax (thing)$ everywhere in the language. Also string literals without prefix or suffix will make it possible to have operator'' and operator"" or Tagged Template Strings or any other versatile syntax in Cpp2.

[msadeqhe]

@MichaelCook, I like the idea to use backslash syntax \keyword.

Because it only works on keywords, if Cpp2 has binary operator \, it wouldn't conflict with it:

// Treats `type` keyword as identifier.
x: \type = ();

// binary operator \
y: = var0 \ var1;

Also unary prefix and postfix operators \ wouldn't conflict with \keyword because they would be applied to identifiers.

[msadeqhe]

These are other use cases and reasons why it does matter in addition to C and Cpp1 language interop:

• When Cpp2 introduces a new keyword in the future, a simple find and replace from keyword to \keyword (or whatever else) helps programmers to migrate the source code of their programs and libraries.
• \keyword (or whatever else) is more readable than workarounds to treat a keyword as an identifier.
• It allows to use keywords for the name of interfaces and functions in APIs:

variable.\if(count < 10).\return();

[jcanizales]

Therefore it's not possible to use such identifiers in Cpp2 when dealing with Cpp1 API

Could you give an example C++ API that would not be usable from Cpp2? Naming variables is not such a case.