Save the types in the typechecked syntax tree

When working on development tools that use the GHC API as a backend, it is useful to have information on the types (or kinds) of the elements of the syntax tree (expressions, patterns, types).

I found that the lack of this semantic information is limiting in some cases of refactoring transformations (for example to generate the type signature or extract a subexpression to a binding with type signature), and is necessary for tools that try to fix common programmer errors. But there should be other kind of tools that this little change may help.

The type is currently saved for some expressions and most patterns but it would be useful if it would be available uniformly.

It could be implemented nicely by adding type information to the X* GhcTc type families.

I plan to implement these changes, I'm just asking the opinion of the developers about a change in this direction.

Trac metadata

Trac field	Value
Version	8.4.3
Type	FeatureRequest
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed milestone to %8.6.1

changed weight to 5

added Tfeature request Trac import labels

One way to get the type of an expression is to desugar it using dsExpr and then using exprType.

Moreover, the post-typechecked tree is already annotated with enough type information to be able to get its type easily. We just need someone to write hsExprType :: HsExpr GhcTc -> Type. It should not be difficult to do this. We already have its near cousin hsPatType :: Pat GhcTc -> Type.

ticket:15320#comment:156030 is true, but I can't imagine it's all that difficult to get the type from a HsExpr GhcTc directly. I don't think we have that function currently, but I think hsExprType :: HsExpr GhcTc -> Type should be quite doable.

I'm concerned that reconstructing the types of multiple subexpressions/subpatterns takes a lot of calculation time. In my opinion, it would be better to save the types where we have them.

But GHC itself has no need for such information, so it seems that doing this would necessarily slow down every compilation... so I'm worried that everyone will have to pay the cost of this feature. On the other hand, you could define a new pass (an alternative to GhcTc) that adds the type information and then calculate all the types once, when you need them, but never again.

Let's do the hsExprType route first. We can always memoise this function in the data structure later -- but I agree with Richard that doing so seems to impose a tax on all users willy-nilly, which sounds unattractive.

Ok, I will try to go for hsExprType :: HsExpr GhcTc -> Type and hsTypeKind :: HsType GhcTc -> Kind.

You'll have a very hard time with the latter: GHC never produces HsType GhcTcs. Instead, the kind-checker just produces TcTypes, which are in the Core AST, not the Haskell one.

changed milestone to %8.8.1

These won't be fixed for in GHC 8.6.

changed milestone to %8.10.1

Bumping milestones of low-priority tickets.

mentioned in issue #16233

added hie files label

added Pnormal label

mentioned in issue #17331

mentioned in merge request !2182 (closed)

removed milestone

mentioned in merge request !3866