Introduce stringer

runtime/interpreter/interpreter.go

@@ -4866,6 +4866,10 @@ func (interpreter *Interpreter) GetInterfaceType(
  typeID TypeID,
 ) (*sema.InterfaceType, error) {
  if location == nil {
+ var interfaceType = sema.NativeInterfaceTypes[qualifiedIdentifier]
+ if interfaceType != nil {
+ return interfaceType, nil
+ }
  return nil, InterfaceMissingLocationError{
  QualifiedIdentifier: qualifiedIdentifier,
  }

runtime/sema/bool_type.go

@@ -31,6 +31,9 @@ var BoolType = &SimpleType{
  Comparable: true,
  Exportable: true,
  Importable: true,
+ conformances: []*InterfaceType{
+ StructStringerType,
+ },
 }
 
 var BoolTypeAnnotation = NewTypeAnnotation(BoolType)

runtime/sema/character.cdc

@@ -1,6 +1,6 @@
 
 access(all)
-struct Character: Storable, Primitive, Equatable, Comparable, Exportable, Importable {
+struct Character: Storable, Primitive, Equatable, Comparable, Exportable, Importable, StructStringer {
 
  /// The byte array of the UTF-8 encoding.
  access(all)

runtime/sema/gen/main.go

@@ -164,6 +164,9 @@ type typeDecl struct {
  memberDeclarations []ast.Declaration
  nestedTypes []*typeDecl
  hasConstructor bool
+
+ // used in simpleType generation
+ conformances []string
 }
 
 type generator struct {
@@ -572,6 +575,8 @@ func (g *generator) VisitCompositeDeclaration(decl *ast.CompositeDeclaration) (_
  ))
  }
  typeDecl.memberAccessible = true
+ case "StructStringer":
+ typeDecl.conformances = append(typeDecl.conformances, "StructStringerType")
  }
  }
 
@@ -736,8 +741,151 @@ func (g *generator) VisitCompositeDeclaration(decl *ast.CompositeDeclaration) (_
  return
 }
 
-func (*generator) VisitInterfaceDeclaration(_ *ast.InterfaceDeclaration) struct{} {
- panic("interface declarations are not supported")
+func (g *generator) VisitInterfaceDeclaration(decl *ast.InterfaceDeclaration) (_ struct{}) {
+ compositeKind := decl.CompositeKind
+ switch compositeKind {
+ case common.CompositeKindStructure,
+ common.CompositeKindResource,
+ common.CompositeKindContract:
+ break
+ default:
+ panic(fmt.Sprintf("%s declarations are not supported", compositeKind.Name()))
+ }
+
+ typeName := decl.Identifier.Identifier
+
+ typeDecl := &typeDecl{
+ typeName: typeName,
+ fullTypeName: g.newFullTypeName(typeName),
+ compositeKind: compositeKind,
+ }
+
+ if len(g.typeStack) > 0 {
+ parentType := g.typeStack[len(g.typeStack)-1]
+ parentType.nestedTypes = append(
+ parentType.nestedTypes,
+ typeDecl,
+ )
+ }
+
+ g.typeStack = append(
+ g.typeStack,
+ typeDecl,
+ )
+ defer func() {
+ // Pop
+ lastIndex := len(g.typeStack) - 1
+ g.typeStack[lastIndex] = nil
+ g.typeStack = g.typeStack[:lastIndex]
+ }()
+
+ for _, memberDeclaration := range decl.Members.Declarations() {
+ generateDeclaration(g, memberDeclaration)
+
+ // Visiting unsupported declarations panics,
+ // so only supported member declarations are added
+ typeDecl.memberDeclarations = append(
+ typeDecl.memberDeclarations,
+ memberDeclaration,
+ )
+ }
+
+ var typeVarDecl = interfaceTypeExpr(typeDecl)
+
+ fullTypeName := typeDecl.fullTypeName
+
+ tyVarName := typeVarName(fullTypeName)
+
+ g.addDecls(
+ goConstDecl(
+ typeNameVarName(fullTypeName),
+ goStringLit(typeName),
+ ),
+ goVarDecl(
+ tyVarName,
+ typeVarDecl,
+ ),
+ )
+
+ memberDeclarations := typeDecl.memberDeclarations
+
+ if len(memberDeclarations) > 0 {
+
+ // func init() {
+ // members := []*Member{...}
+ // t.Members = MembersAsMap(members)
+ // t.Fields = MembersFieldNames(members)=
+ // }
+
+ members := membersExpr(
+ fullTypeName,
+ tyVarName,
+ memberDeclarations,
+ )
+
+ const membersVariableIdentifier = "members"
+
+ stmts := []dst.Stmt{
+ &dst.DeclStmt{
+ Decl: goVarDecl(
+ membersVariableIdentifier,
+ members,
+ ),
+ },
+ &dst.AssignStmt{
+ Lhs: []dst.Expr{
+ &dst.SelectorExpr{
+ X: dst.NewIdent(tyVarName),
+ Sel: dst.NewIdent("Members"),
+ },
+ },
+ Tok: token.ASSIGN,
+ Rhs: []dst.Expr{
+ &dst.CallExpr{
+ Fun: &dst.Ident{
+ Name: "MembersAsMap",
+ Path: semaPath,
+ },
+ Args: []dst.Expr{
+ dst.NewIdent(membersVariableIdentifier),
+ },
+ },
+ },
+ },
+ &dst.AssignStmt{
+ Lhs: []dst.Expr{
+ &dst.SelectorExpr{
+ X: dst.NewIdent(tyVarName),
+ Sel: dst.NewIdent("Fields"),
+ },
+ },
+ Tok: token.ASSIGN,
+ Rhs: []dst.Expr{
+ &dst.CallExpr{
+ Fun: &dst.Ident{
+ Name: "MembersFieldNames",
+ Path: semaPath,
+ },
+ Args: []dst.Expr{
+ dst.NewIdent(membersVariableIdentifier),
+ },
+ },
+ },
+ },
+ }
+
+ g.addDecls(
+ &dst.FuncDecl{
+ Name: dst.NewIdent("init"),
+ Type: &dst.FuncType{},
+ Body: &dst.BlockStmt{
+ List: stmts,
+ },
+ },
+ )
+ }
+
+ return
 }
 
 func (*generator) VisitAttachmentDeclaration(_ *ast.AttachmentDeclaration) struct{} {
@@ -1591,6 +1739,9 @@ func simpleTypeLiteral(ty *typeDecl) dst.Expr {
  // Comparable: false,
  // Exportable: false,
  // Importable: false,
+ // comformances: []*InterfaceType {
+ // StructStringer,
+ // }
  //}
 
  isResource := ty.compositeKind == common.CompositeKindResource
@@ -1609,6 +1760,26 @@ func simpleTypeLiteral(ty *typeDecl) dst.Expr {
  goKeyValue("ContainFields", goBoolLit(ty.memberAccessible)),
  }
 
+ if len(ty.conformances) > 0 {
+ var elts = []dst.Expr{}
+ for _, conformance := range ty.conformances {
+ elts = append(elts, &dst.Ident{
+ Name: conformance,
+ Path: semaPath,
+ })
+ }
+ elements = append(elements, goKeyValue("conformances", &dst.CompositeLit{
+ Type: &dst.ArrayType{
+ Elt: &dst.StarExpr{
+ X: &dst.Ident{
+ Name: "InterfaceType",
+ },
+ },
+ },
+ Elts: elts,
+ }))
+ }
+
  return &dst.UnaryExpr{
  Op: token.AND,
  X: &dst.CompositeLit{
@@ -2069,6 +2240,100 @@ func compositeTypeLiteral(ty *typeDecl) dst.Expr {
  }
 }
 
+func interfaceTypeExpr(ty *typeDecl) dst.Expr {
+
+ // func() *InterfaceType {
+ // var t = &InterfaceType{
+ // Identifier: FooTypeName,
+ // CompositeKind: common.CompositeKindStructure,
+ // }
+ //
+ // t.SetNestedType(FooBarTypeName, FooBarType)
+ // return t
+ // }()
+
+ const typeVarName = "t"
+
+ statements := []dst.Stmt{
+ &dst.DeclStmt{
+ Decl: goVarDecl(
+ typeVarName,
+ interfaceTypeLiteral(ty),
+ ),
+ },
+ }
+
+ for _, nestedType := range ty.nestedTypes {
+ statements = append(
+ statements,
+ &dst.ExprStmt{
+ X: &dst.CallExpr{
+ Fun: &dst.SelectorExpr{
+ X: dst.NewIdent(typeVarName),
+ Sel: dst.NewIdent("SetNestedType"),
+ },
+ Args: []dst.Expr{
+ typeNameVarIdent(nestedType.fullTypeName),
+ typeVarIdent(nestedType.fullTypeName),
+ },
+ },
+ },
+ )
+ }
+
+ statements = append(
+ statements,
+ &dst.ReturnStmt{
+ Results: []dst.Expr{
+ dst.NewIdent(typeVarName),
+ },
+ },
+ )
+
+ return &dst.CallExpr{
+ Fun: &dst.FuncLit{
+ Type: &dst.FuncType{
+ Func: true,
+ Results: &dst.FieldList{
+ List: []*dst.Field{
+ {
+ Type: &dst.StarExpr{
+ X: &dst.Ident{
+ Name: "InterfaceType",
+ Path: semaPath,
+ },
+ },
+ },
+ },
+ },
+ },
+ Body: &dst.BlockStmt{
+ List: statements,
+ },
+ },
+ }
+}
+
+func interfaceTypeLiteral(ty *typeDecl) dst.Expr {
+ kind := compositeKindExpr(ty.compositeKind)
+
+ elements := []dst.Expr{
+ goKeyValue("Identifier", typeNameVarIdent(ty.fullTypeName)),
+ goKeyValue("CompositeKind", kind),
+ }
+
+ return &dst.UnaryExpr{
+ Op: token.AND,
+ X: &dst.CompositeLit{
+ Type: &dst.Ident{
+ Name: "InterfaceType",
+ Path: semaPath,
+ },
+ Elts: elements,
+ },
+ }
+}
+
 func typeAnnotationCallExpr(ty dst.Expr) *dst.CallExpr {
  return &dst.CallExpr{
  Fun: &dst.Ident{

runtime/sema/path_type.go

@@ -31,6 +31,9 @@ var PathType = &SimpleType{
  Comparable: false,
  Exportable: true,
  Importable: true,
+ conformances: []*InterfaceType{
+ StructStringerType,
+ },
 }
 
 var PathTypeAnnotation = NewTypeAnnotation(PathType)
@@ -48,6 +51,9 @@ var StoragePathType = &SimpleType{
  Comparable: false,
  Exportable: true,
  Importable: true,
+ conformances: []*InterfaceType{
+ StructStringerType,
+ },
 }
 
 var StoragePathTypeAnnotation = NewTypeAnnotation(StoragePathType)
@@ -65,6 +71,9 @@ var CapabilityPathType = &SimpleType{
  Comparable: false,
  Exportable: true,
  Importable: true,
+ conformances: []*InterfaceType{
+ StructStringerType,
+ },
 }
 
 var CapabilityPathTypeAnnotation = NewTypeAnnotation(CapabilityPathType)
@@ -82,6 +91,9 @@ var PublicPathType = &SimpleType{
  Comparable: false,
  Exportable: true,
  Importable: true,
+ conformances: []*InterfaceType{
+ StructStringerType,
+ },
 }
 
 var PublicPathTypeAnnotation = NewTypeAnnotation(PublicPathType)
@@ -99,6 +111,9 @@ var PrivatePathType = &SimpleType{
  Comparable: false,
  Exportable: true,
  Importable: true,
+ conformances: []*InterfaceType{
+ StructStringerType,
+ },
 }
 
 var PrivatePathTypeAnnotation = NewTypeAnnotation(PrivatePathType)