lib/vdl/compile/interface.go - release.go.x.ref - Git at Google

 // Copyright 2015 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package compile

 import (
 	"v.io/v23/vdl"
 	"v.io/x/lib/toposort"
 	"v.io/x/ref/lib/vdl/parse"
 )

 // compileInterfaces is the "entry point" to the rest of this file.  It takes
 // the interfaces defined in pfiles and compiles them into Interfaces in pkg.
 func compileInterfaces(pkg *Package, pfiles []*parse.File, env *Env) {
 	id := ifaceDefiner{pkg, pfiles, env, make(map[string]*ifaceBuilder)}
 	if id.Declare(); !env.Errors.IsEmpty() {
 		return
 	}
 	id.Define()
 }

 // ifaceDefiner defines interfaces in a package.  This is split into two phases:
 // 1) Declare ensures local interface references can be resolved.
 // 2) Define sorts in dependency order, and defines each interface.
 //
 // It holds a builders map from interface name to ifaceBuilder, where the
 // ifaceBuilder is responsible for compiling and defining a single interface.
 type ifaceDefiner struct {
 	pkg      *Package
 	pfiles   []*parse.File
 	env      *Env
 	builders map[string]*ifaceBuilder
 }

 type ifaceBuilder struct {
 	def  *Interface
 	pdef *parse.Interface
 }

 func printIfaceBuilderName(ibuilder interface{}) string {
 	return ibuilder.(*ifaceBuilder).def.Name
 }

 // Declare creates builders for each interface defined in the package.
 func (id ifaceDefiner) Declare() {
 	for ix := range id.pkg.Files {
 		file, pfile := id.pkg.Files[ix], id.pfiles[ix]
 		for _, pdef := range pfile.Interfaces {
 			export, err := validIdent(pdef.Name, reservedNormal)
 			if err != nil {
 				id.env.prefixErrorf(file, pdef.Pos, err, "interface %s invalid name", pdef.Name)
 				continue // keep going to catch more errors
 			}
 			detail := identDetail("interface", file, pdef.Pos)
 			if err := file.DeclareIdent(pdef.Name, detail); err != nil {
 				id.env.prefixErrorf(file, pdef.Pos, err, "interface %s name conflict", pdef.Name)
 				continue
 			}
 			def := &Interface{NamePos: NamePos(pdef.NamePos), Exported: export, File: file}
 			id.builders[pdef.Name] = &ifaceBuilder{def, pdef}
 		}
 	}
 }

 // Define interfaces.  We sort by dependencies on other interfaces in this
 // package.  The sorting is to ensure there are no cycles.
 func (id ifaceDefiner) Define() {
 	// Populate sorter with dependency information.  The sorting ensures that the
 	// list of interfaces within each file is topologically sorted, and also
 	// deterministic; in the absence of interface embeddings, interfaces are
 	// listed in the same order they were defined in the parsed files.
 	var sorter toposort.Sorter
 	for _, pfile := range id.pfiles {
 		for _, pdef := range pfile.Interfaces {
 			b := id.builders[pdef.Name]
 			sorter.AddNode(b)
 			for _, dep := range id.getLocalDeps(b) {
 				sorter.AddEdge(b, dep)
 			}
 		}
 	}
 	// Sort and check for cycles.
 	sorted, cycles := sorter.Sort()
 	if len(cycles) > 0 {
 		cycleStr := toposort.DumpCycles(cycles, printIfaceBuilderName)
 		first := cycles[0][0].(*ifaceBuilder)
 		id.env.Errorf(first.def.File, first.def.Pos, "package %v has cyclic interfaces: %v", id.pkg.Name, cycleStr)
 		return
 	}
 	// Define all interfaces.  Since we add the interfaces as we go and evaluate
 	// in topological order, dependencies are guaranteed to be resolvable when we
 	// get around to defining the interfaces that embed on them.
 	for _, ibuilder := range sorted {
 		b := ibuilder.(*ifaceBuilder)
 		id.define(b)
 		addIfaceDef(b.def)
 	}
 }

 // addIfaceDef updates our various structures to add a new interface.
 func addIfaceDef(def *Interface) {
 	def.File.Interfaces = append(def.File.Interfaces, def)
 	def.File.Package.ifaceDefs = append(def.File.Package.ifaceDefs, def)
 	def.File.Package.ifaceMap[def.Name] = def
 }

 // getLocalDeps returns the list of interface dependencies for b that are in
 // this package.
 func (id ifaceDefiner) getLocalDeps(b *ifaceBuilder) (deps []*ifaceBuilder) {
 	for _, pe := range b.pdef.Embeds {
 		// Embeddings of other interfaces in this package are all we care about.
 		if dep := id.builders[pe.Name]; dep != nil {
 			deps = append(deps, dep)
 		}
 	}
 	return
 }

 func (id ifaceDefiner) define(b *ifaceBuilder) {
 	// Methods must be defined before embeddings, so that we can check whether any
 	// of the embeddings add duplicate methods.
 	methods := id.defineMethods(b)
 	id.defineEmbeds(b, methods)
 }

 func (id ifaceDefiner) defineMethods(b *ifaceBuilder) map[string]*Method {
 	def, file := b.def, b.def.File
 	defined := make(map[string]*Method)
 	// Now validate and define each method.
 	for _, pm := range b.pdef.Methods {
 		if err := validExportedIdent(pm.Name, reservedFirstRuneLower); err != nil {
 			id.env.Errorf(file, pm.Pos, "method %s name (%s)", pm.Name, err)
 			continue // keep going to catch more errors
 		}
 		if dup := defined[pm.Name]; dup != nil {
 			id.env.Errorf(file, pm.Pos, "method %s redefined (previous at %s)", pm.Name, dup.Pos)
 			continue // keep going to catch more errors
 		}
 		m := &Method{NamePos: NamePos(pm.NamePos), Interface: def}
 		m.InArgs = id.defineArgs(in, m.NamePos, pm.InArgs, file)
 		m.OutArgs = id.defineArgs(out, m.NamePos, pm.OutArgs, file)
 		m.InStream = id.defineStreamType(pm.InStream, file)
 		m.OutStream = id.defineStreamType(pm.OutStream, file)
 		m.Tags = id.defineTags(pm.Tags, file)
 		def.Methods = append(def.Methods, m)
 		defined[pm.Name] = m
 	}
 	return defined
 }

 func (id ifaceDefiner) defineEmbeds(b *ifaceBuilder, methods map[string]*Method) {
 	def, file := b.def, b.def.File
 	seen := make(map[string]*parse.NamePos)
 	for _, pe := range b.pdef.Embeds {
 		if dup := seen[pe.Name]; dup != nil {
 			id.env.Errorf(file, pe.Pos, "interface %s duplicate embedding (previous at %s)", pe.Name, dup.Pos)
 			continue // keep going to catch more errors
 		}
 		seen[pe.Name] = pe
 		// Resolve the embedded interface.
 		embed, matched := id.env.ResolveInterface(pe.Name, file)
 		if embed == nil {
 			id.env.Errorf(file, pe.Pos, "interface %s undefined", pe.Name)
 			continue // keep going to catch more errors
 		}
 		if len(matched) < len(pe.Name) {
 			id.env.Errorf(file, pe.Pos, "interface %s invalid (%s unmatched)", pe.Name, pe.Name[len(matched):])
 			continue // keep going to catch more errors
 		}
 		// Check for method redefinition in the embeddings.
 		//
 		// TODO(toddw): We may relax this rule in the future, to allow duplicate
 		// methods with identical signatures.
 		for _, m := range embed.AllMethods() {
 			if dup := methods[m.Name]; dup != nil {
 				pos1, pos2 := m.Pos.String(), dup.Pos.String()
 				if m.Interface != def {
 					pos1 = fpString(m.Interface.File, m.Pos)
 				}
 				if dup.Interface != def {
 					pos2 = fpString(dup.Interface.File, dup.Pos)
 				}
 				id.env.Errorf(file, pe.Pos, "embedded method %s redefined (defined at %s and %s)", m.Name, pos1, pos2)
 			}
 			methods[m.Name] = m
 		}
 		def.Embeds = append(def.Embeds, embed)
 	}
 }

 type inout string

 const (
 	in  inout = "in"
 	out inout = "out"
 )

 func (id ifaceDefiner) defineArgs(io inout, method NamePos, pargs []*parse.Field, file *File) (args []*Field) {
 	seen := make(map[string]*parse.Field)
 	for _, parg := range pargs {
 		if dup := seen[parg.Name]; dup != nil && parg.Name != "" {
 			id.env.Errorf(file, parg.Pos, "method %s arg %s duplicate name (previous at %s)", method.Name, parg.Name, dup.Pos)
 			continue // keep going to catch more errors
 		}
 		seen[parg.Name] = parg
 		switch {
 		case io == in && parg.Name == "":
 			id.env.Errorf(file, parg.Pos, "method %s in-arg unnamed (must name all in-args)", method.Name)
 			continue // keep going to catch more errors
 		case io == out && len(pargs) > 1 && parg.Name == "":
 			id.env.Errorf(file, parg.Pos, "method %s out-arg unnamed (must name all out-args if there are more than 1)", method.Name)
 			continue // keep going to catch more errors
 		}
 		if parg.Name != "" {
 			if _, err := validIdent(parg.Name, reservedFirstRuneLower); err != nil {
 				id.env.prefixErrorf(file, parg.Pos, err, "method %s invalid arg %s", method.Name, parg.Name)
 				continue // keep going to catch more errors
 			}
 		}
 		arg := &Field{NamePos(parg.NamePos), compileExportedType(parg.Type, file, id.env)}
 		args = append(args, arg)
 	}
 	return
 }

 func (id ifaceDefiner) defineStreamType(ptype parse.Type, file *File) *vdl.Type {
 	if ptype == nil {
 		return nil
 	}
 	if tn, ok := ptype.(*parse.TypeNamed); ok && tn.Name == "_" {
 		// Special-case the _ placeholder, which means there's no stream type.
 		return nil
 	}
 	return compileExportedType(ptype, file, id.env)
 }

 func (id ifaceDefiner) defineTags(ptags []parse.ConstExpr, file *File) (tags []*vdl.Value) {
 	// TODO(toddw): Should we require that tag types are transitively exported?
 	for _, ptag := range ptags {
 		if tag := compileConst("tag", nil, ptag, file, id.env); tag != nil {
 			tags = append(tags, tag)
 		}
 	}
 	return
 }
	// Copyright 2015 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package compile

	import (
	"v.io/v23/vdl"
	"v.io/x/lib/toposort"
	"v.io/x/ref/lib/vdl/parse"
	)

	// compileInterfaces is the "entry point" to the rest of this file. It takes
	// the interfaces defined in pfiles and compiles them into Interfaces in pkg.
	func compileInterfaces(pkg Package, pfiles []parse.File, env *Env) {
	id := ifaceDefiner{pkg, pfiles, env, make(map[string]*ifaceBuilder)}
	if id.Declare(); !env.Errors.IsEmpty() {
	return
	}
	id.Define()
	}

	// ifaceDefiner defines interfaces in a package. This is split into two phases:
	// 1) Declare ensures local interface references can be resolved.
	// 2) Define sorts in dependency order, and defines each interface.
	//
	// It holds a builders map from interface name to ifaceBuilder, where the
	// ifaceBuilder is responsible for compiling and defining a single interface.
	type ifaceDefiner struct {
	pkg *Package
	pfiles []*parse.File
	env *Env
	builders map[string]*ifaceBuilder
	}

	type ifaceBuilder struct {
	def *Interface
	pdef *parse.Interface
	}

	func printIfaceBuilderName(ibuilder interface{}) string {
	return ibuilder.(*ifaceBuilder).def.Name
	}

	// Declare creates builders for each interface defined in the package.
	func (id ifaceDefiner) Declare() {
	for ix := range id.pkg.Files {
	file, pfile := id.pkg.Files[ix], id.pfiles[ix]
	for _, pdef := range pfile.Interfaces {
	export, err := validIdent(pdef.Name, reservedNormal)
	if err != nil {
	id.env.prefixErrorf(file, pdef.Pos, err, "interface %s invalid name", pdef.Name)
	continue // keep going to catch more errors
	}
	detail := identDetail("interface", file, pdef.Pos)
	if err := file.DeclareIdent(pdef.Name, detail); err != nil {
	id.env.prefixErrorf(file, pdef.Pos, err, "interface %s name conflict", pdef.Name)
	continue
	}
	def := &Interface{NamePos: NamePos(pdef.NamePos), Exported: export, File: file}
	id.builders[pdef.Name] = &ifaceBuilder{def, pdef}
	}
	}
	}

	// Define interfaces. We sort by dependencies on other interfaces in this
	// package. The sorting is to ensure there are no cycles.
	func (id ifaceDefiner) Define() {
	// Populate sorter with dependency information. The sorting ensures that the
	// list of interfaces within each file is topologically sorted, and also
	// deterministic; in the absence of interface embeddings, interfaces are
	// listed in the same order they were defined in the parsed files.
	var sorter toposort.Sorter
	for _, pfile := range id.pfiles {
	for _, pdef := range pfile.Interfaces {
	b := id.builders[pdef.Name]
	sorter.AddNode(b)
	for _, dep := range id.getLocalDeps(b) {
	sorter.AddEdge(b, dep)
	}
	}
	}
	// Sort and check for cycles.
	sorted, cycles := sorter.Sort()
	if len(cycles) > 0 {
	cycleStr := toposort.DumpCycles(cycles, printIfaceBuilderName)
	first := cycles[0][0].(*ifaceBuilder)
	id.env.Errorf(first.def.File, first.def.Pos, "package %v has cyclic interfaces: %v", id.pkg.Name, cycleStr)
	return
	}
	// Define all interfaces. Since we add the interfaces as we go and evaluate
	// in topological order, dependencies are guaranteed to be resolvable when we
	// get around to defining the interfaces that embed on them.
	for _, ibuilder := range sorted {
	b := ibuilder.(*ifaceBuilder)
	id.define(b)
	addIfaceDef(b.def)
	}
	}

	// addIfaceDef updates our various structures to add a new interface.
	func addIfaceDef(def *Interface) {
	def.File.Interfaces = append(def.File.Interfaces, def)
	def.File.Package.ifaceDefs = append(def.File.Package.ifaceDefs, def)
	def.File.Package.ifaceMap[def.Name] = def
	}

	// getLocalDeps returns the list of interface dependencies for b that are in
	// this package.
	func (id ifaceDefiner) getLocalDeps(b ifaceBuilder) (deps []ifaceBuilder) {
	for _, pe := range b.pdef.Embeds {
	// Embeddings of other interfaces in this package are all we care about.
	if dep := id.builders[pe.Name]; dep != nil {
	deps = append(deps, dep)
	}
	}
	return
	}

	func (id ifaceDefiner) define(b *ifaceBuilder) {
	// Methods must be defined before embeddings, so that we can check whether any
	// of the embeddings add duplicate methods.
	methods := id.defineMethods(b)
	id.defineEmbeds(b, methods)
	}

	func (id ifaceDefiner) defineMethods(b ifaceBuilder) map[string]Method {
	def, file := b.def, b.def.File
	defined := make(map[string]*Method)
	// Now validate and define each method.
	for _, pm := range b.pdef.Methods {
	if err := validExportedIdent(pm.Name, reservedFirstRuneLower); err != nil {
	id.env.Errorf(file, pm.Pos, "method %s name (%s)", pm.Name, err)
	continue // keep going to catch more errors
	}
	if dup := defined[pm.Name]; dup != nil {
	id.env.Errorf(file, pm.Pos, "method %s redefined (previous at %s)", pm.Name, dup.Pos)
	continue // keep going to catch more errors
	}
	m := &Method{NamePos: NamePos(pm.NamePos), Interface: def}
	m.InArgs = id.defineArgs(in, m.NamePos, pm.InArgs, file)
	m.OutArgs = id.defineArgs(out, m.NamePos, pm.OutArgs, file)
	m.InStream = id.defineStreamType(pm.InStream, file)
	m.OutStream = id.defineStreamType(pm.OutStream, file)
	m.Tags = id.defineTags(pm.Tags, file)
	def.Methods = append(def.Methods, m)
	defined[pm.Name] = m
	}
	return defined
	}

	func (id ifaceDefiner) defineEmbeds(b ifaceBuilder, methods map[string]Method) {
	def, file := b.def, b.def.File
	seen := make(map[string]*parse.NamePos)
	for _, pe := range b.pdef.Embeds {
	if dup := seen[pe.Name]; dup != nil {
	id.env.Errorf(file, pe.Pos, "interface %s duplicate embedding (previous at %s)", pe.Name, dup.Pos)
	continue // keep going to catch more errors
	}
	seen[pe.Name] = pe
	// Resolve the embedded interface.
	embed, matched := id.env.ResolveInterface(pe.Name, file)
	if embed == nil {
	id.env.Errorf(file, pe.Pos, "interface %s undefined", pe.Name)
	continue // keep going to catch more errors
	}
	if len(matched) < len(pe.Name) {
	id.env.Errorf(file, pe.Pos, "interface %s invalid (%s unmatched)", pe.Name, pe.Name[len(matched):])
	continue // keep going to catch more errors
	}
	// Check for method redefinition in the embeddings.
	//
	// TODO(toddw): We may relax this rule in the future, to allow duplicate
	// methods with identical signatures.
	for _, m := range embed.AllMethods() {
	if dup := methods[m.Name]; dup != nil {
	pos1, pos2 := m.Pos.String(), dup.Pos.String()
	if m.Interface != def {
	pos1 = fpString(m.Interface.File, m.Pos)
	}
	if dup.Interface != def {
	pos2 = fpString(dup.Interface.File, dup.Pos)
	}
	id.env.Errorf(file, pe.Pos, "embedded method %s redefined (defined at %s and %s)", m.Name, pos1, pos2)
	}
	methods[m.Name] = m
	}
	def.Embeds = append(def.Embeds, embed)
	}
	}

	type inout string

	const (
	in inout = "in"
	out inout = "out"
	)

	func (id ifaceDefiner) defineArgs(io inout, method NamePos, pargs []parse.Field, file File) (args []*Field) {
	seen := make(map[string]*parse.Field)
	for _, parg := range pargs {
	if dup := seen[parg.Name]; dup != nil && parg.Name != "" {
	id.env.Errorf(file, parg.Pos, "method %s arg %s duplicate name (previous at %s)", method.Name, parg.Name, dup.Pos)
	continue // keep going to catch more errors
	}
	seen[parg.Name] = parg
	switch {
	case io == in && parg.Name == "":
	id.env.Errorf(file, parg.Pos, "method %s in-arg unnamed (must name all in-args)", method.Name)
	continue // keep going to catch more errors
	case io == out && len(pargs) > 1 && parg.Name == "":
	id.env.Errorf(file, parg.Pos, "method %s out-arg unnamed (must name all out-args if there are more than 1)", method.Name)
	continue // keep going to catch more errors
	}
	if parg.Name != "" {
	if _, err := validIdent(parg.Name, reservedFirstRuneLower); err != nil {
	id.env.prefixErrorf(file, parg.Pos, err, "method %s invalid arg %s", method.Name, parg.Name)
	continue // keep going to catch more errors
	}
	}
	arg := &Field{NamePos(parg.NamePos), compileExportedType(parg.Type, file, id.env)}
	args = append(args, arg)
	}
	return
	}

	func (id ifaceDefiner) defineStreamType(ptype parse.Type, file File) vdl.Type {
	if ptype == nil {
	return nil
	}
	if tn, ok := ptype.(*parse.TypeNamed); ok && tn.Name == "_" {
	// Special-case the _ placeholder, which means there's no stream type.
	return nil
	}
	return compileExportedType(ptype, file, id.env)
	}

	func (id ifaceDefiner) defineTags(ptags []parse.ConstExpr, file File) (tags []vdl.Value) {
	// TODO(toddw): Should we require that tag types are transitively exported?
	for _, ptag := range ptags {
	if tag := compileConst("tag", nil, ptag, file, id.env); tag != nil {
	tags = append(tags, tag)
	}
	}
	return
	}