Is there an API that traverses the types in a namespace in the order that they are created in the TypeSpec file?

[Onokaev]

I have used the navigateTypesInNamespace and navigateProgram to traverse the types, but it seems that these functions do not maintain the order in which the types are declared in the typespec file. Is there a different API I can use or am I missing something?

[Onokaev]

typespec/packages/compiler/src/core/semantic-walker.ts

Line 165 in b37f6e4

function navigateNamespaceType(namespace: Namespace, context: NavigationContext) {

This just walks through the types in a certain order

[timotheeguerin]

yeah this will do a depth first traversal, you could traverse the types manually to get a different order.

const namespace = program.getGlobalNamespaceType()
namespace.namespace
namespace.operations
namespace.models
...

However even that might not get you an order like things were defined(Each types being in a different map). Order of declaration has never been something that was defined in TypeSpec(The syntax tree will be ordered but in the type graph the order is not relevant anymore). Importing other files also would affect order in which items are checked.

Could you share more on what you are trying to achieve?

[Onokaev]

Even for items in the same map, say a Map<string, Model>, if one model has a property whose type is another model, the ordering in the map is in such a way that the property type comes immediately after the parent model even if the property type is declared elsewhere in the TypeSpec file

[Onokaev]

Something like namespace.allDeclaredTypes could come in handy for this

[bterlson]

I can see wanting a way to have the order of declaration preserved or accessible in some way, when a single file is involved, but I'm having a hard time understanding what you would want if there are multiple files. Can you say what order you would like to see for the following TypeSpec program:

// main.tsp
import "./a.tsp";
import "./b.tsp";

// a.tsp
model A1 {
  prop: B1;
}

model A2 {
  prop: B2;
}

// b.tsp
model B1 {
  prop: A2;
}

model B2 {
  prop: A1
}

[Onokaev]

Ordering here should be A1, A2, B1, B2

[garethj-msft]

Agreed, when the imports are files, the order shoudl be as if it was a traditional #include and the file linearized

I don't have a good answer for libraries, but I'm sure that doesn't matter for our libraires. But if you're migrating from hand-written output files to generated output files, it is REALLY hard to validate/compare unless as an author you can control the output order explicitly, cos no-one has useful semantic diff tools.