Types, Values, Properties - TypeSpec's types

[I-Al-Istannen]

I opened an issue for an ICE and my intuition for how TypeSpec's types work wasn't correct. I went hunting in the docs, but I still don't quite have a working mental model for how types and properties in TypeSpec interact. This post is sadly a bit of a stream of consciousness, I am not exactly sure what I don't know.

---

From my initial understanding of the world, the type of

  @pattern("[a-z]+")
  foo: string;

foo here would be "a string constrained to [a-z]+". Then I read the paragraph about implementing your own custom decorators in JS/TS, and they don't seem to have the capability to interact at all with the type system.
So the actual type of this is any old regular string and the pattern decorator is just random metadata that gets basically ignored for anything except emitting the final artifact?

There also seems to be a distinction between types (a fixed inbuilt number + user models) and literals (string, int, boolean) and properties (name + type + arbitrary metadata applied by decorators)? Interestingly, the following compiles:

model A {
  @pattern("[a-z]+")
  foo: string;
}
model B {
  foo: A.foo;
}
model C extends A {
  foo: string
}

but this one does not:

model A {
  @pattern("[a-z]+")
  foo: string;
}
model B {
  foo: A.foo;
}
model C extends B {
  foo: string
}

while this one does again:

model A {
  @pattern("[a-z]+")
  foo: string;
}
model B {
  foo: A.foo::type;
}
model C extends B {
  foo: string
}

What is the "type A.foo" here? As the following does not compile, A.foo seems to be an opaque, nominal type? Where does it come from and where does it fit into the hierarchy?

model A {
  @pattern("[a-z]+")
  foo: string;
}
model B {
  foo: A.foo;
}
model C extends B {
  @pattern("[a-z]+")
  foo: string
}

[timotheeguerin]

First lets separate the bugs:

model B {
  foo: A.foo::type;
}

This is broken today, however what it would mean is that the property type of B.foo is exactly a string(would be the equivalent of doing A["foo"] in typescript

Now for referencing properties:

When you reference a property it is its own type(that property) this means even though the property type is a string, you cannot assign a string to i(why 2nd and last case fails as overrides need to be assignable to the parent). The issue is that the property can contain additional information which could make it incorrect to assume it is interchangeable with its type.

[I-Al-Istannen]

I see, thanks! That makes sense. I think the ::type is what I was after originally, as it only had scalar types. My usecase was creating a trimmed-down version of another model. The full model included derived values but for creation those don't need to be specified. I think an OmitProperties type trimming out the unneeded ones would be the best option next time for this :)