Mojom frontend: Detect Ill-founded Types

mojom/mojom_tool/mojom/types.go

 // Copyright 2015 The Chromium 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 mojom
 
 import (
         "fmt"
         "math"
         "mojom/mojom_tool/lexer"
@@ skipping 113 matching lines @@
 
         // SerializationSize() is invoked after the resolution and validation phases.
         // It returns the number of bytes necessary to serialize an instance of the type
         // to which this type reference resolves in Mojo serialization.
         SerializationSize() uint32
 
         // SerializationAlignment() is invoked after the resolution and validation phases.
         // It returns the number of bytes on which an instance of the type to which this
         // type reference resolves must be aligned during Mojo serialization.
         SerializationAlignment() uint32
+
+        // NonAvoidableUserType is invoked after the resolution and validation phases.
+        // It returns a non-nil UserDefinedType just in case this type
+        // reference resolves to a type the serialization of which will
+        // include a non-nullable pointer to a struct or union. In that case a
+        // non-nil UserDefinedType representing that struct or union is returnd.
+        //
+        // This method is used during the analysis of ill-founded types. The goal of
+        // that analysis is to find user-defined types that are unserializable because
+        // every instance of the type would involve a cycle.
+        //
+        // For example, suppose there is a struct Foo that contains a field |x|
+        // and the type of x is Foo. An instance of Foo could not be serialized because
+        // the cycle would cause an infinite recursion.
+        //
+        // However a cycle in the type graph is allowed if it is avoidable.
+        // For example if the type of x were instead Foo? then an instance
+        // of Foo could be serialized by setting x to null at some level
+        // of the recursion.
+        //
+        // Similarly if the type of x were array<Foo, 1> then an instance of
+        // Foo would not be serializable. However it allowed for the type of
+        // x to be any of the following:
+        //   - array<Foo>
+        //   - array<Foo?, 1>
+        //   - array<Foo, 1>?
+        NonAvoidableUserType() UserDefinedType
 }
 
 /////////////////////////////////////////////////////////////
 // SimpleType
 /////////////////////////////////////////////////////////////
 type SimpleType int
 
 const (
         SimpleTypeBool SimpleType = iota
         SimpleTypeDouble
@@ skipping 210 matching lines @@
                 return 8
         default:
                 panic(fmt.Sprintf("unexpected type: &d", t))
         }
 }
 
 func (t SimpleType) SerializationAlignment() uint32 {
         return t.SerializationSize()
 }
 
+func (SimpleType) NonAvoidableUserType() UserDefinedType {
+        return nil
+}
+
 func (t SimpleType) String() string {
         switch t {
         case SimpleTypeBool:
                 return "bool"
         case SimpleTypeDouble:
                 return "double"
         case SimpleTypeFloat:
                 return "float"
         case SimpleTypeInt8:
                 return "int8"
@@ skipping 40 matching lines @@
 }
 
 func (StringType) SerializationSize() uint32 {
         return 8
 }
 
 func (StringType) SerializationAlignment() uint32 {
         return 8
 }
 
+func (StringType) NonAvoidableUserType() UserDefinedType {
+        return nil
+}
+
 // StringLiteralType is a global singleton representing the unique LiteralType string.
 var StringLiteralType LiteralType = StringType{}
 
 // A StringType is a LiteralType:
 
 func (StringType) LiteralTypeKind() TypeKind {
         return TypeKindString
 }
 
 // A StringType is a ConcreteType:
@@ skipping 77 matching lines @@
 }
 
 func (HandleTypeRef) SerializationSize() uint32 {
         return 4
 }
 
 func (HandleTypeRef) SerializationAlignment() uint32 {
         return 4
 }
 
+func (HandleTypeRef) NonAvoidableUserType() UserDefinedType {
+        return nil
+}
+
 func (h HandleTypeRef) HandleKind() HandleKind {
         return h.kind
 }
 
 func (HandleTypeRef) TypeRefKind() TypeKind {
         return TypeKindHandle
 }
 
 func (HandleTypeRef) MarkUsedAsMapKey() bool {
         return false
@@ skipping 125 matching lines @@
 }
 
 func (a ArrayTypeRef) FixedLength() int32 {
         return a.fixedLength
 }
 
 func (a ArrayTypeRef) ElementType() TypeRef {
         return a.elementType
 }
 
+func (a ArrayTypeRef) NonAvoidableUserType() UserDefinedType {
+        if a.nullable || a.fixedLength <= 0 {
+                return nil
+        }
+        return a.elementType.NonAvoidableUserType()
+}
+
 // An ArrayTypeRef is a TypeRef:
 
 func (ArrayTypeRef) TypeRefKind() TypeKind {
         return TypeKindArray
 }
 
 func (ArrayTypeRef) MarkUsedAsMapKey() bool {
         return false
 }
 
@@ skipping 64 matching lines @@
 }
 
 func (MapTypeRef) SerializationSize() uint32 {
         return 8
 }
 
 func (MapTypeRef) SerializationAlignment() uint32 {
         return 8
 }
 
+func (MapTypeRef) NonAvoidableUserType() UserDefinedType {
+        return nil
+}
+
 func (m MapTypeRef) KeyType() TypeRef {
         return m.keyType
 }
 
 func (m MapTypeRef) ValueType() TypeRef {
         return m.valueType
 }
 
 // A MapTypeRef is a TypeRef:
 
@@ skipping 118 matching lines @@
         return t.resolvedType.SerializationSize()
 }
 
 func (t *UserTypeRef) SerializationAlignment() uint32 {
         if t.resolvedType == nil {
                 panic("This method should only be invoked after successful resolution.")
         }
         return t.resolvedType.SerializationAlignment()
 }
 
+func (t *UserTypeRef) NonAvoidableUserType() UserDefinedType {
+        if t.nullable || t.interfaceRequest {
+                return nil
+        }
+        if t.resolvedType == nil {
+                panic("This method should only be invoked after successful resolution.")
+        }
+        switch udt := t.resolvedType.(type) {
+        case *MojomStruct, *MojomUnion:
+                return udt
+        }
+        return nil
+}
+
 func (t *UserTypeRef) IsInterfaceRequest() bool {
         return t.interfaceRequest
 }
 
 func (t *UserTypeRef) Identifier() string {
         return t.identifier
 }
 
 // A UserTypeRef is a TypeRef:
 
@@ skipping 524 matching lines @@
         default:
                 panic(fmt.Sprintf("Unknown LiteralAssignmentKind %d", k))
         }
 }
 
 type LiteralAssignment struct {
         assignedValue LiteralValue
         variableName  string
         kind          LiteralAssignmentKind
 }