Traits

src/compiler/Syntax/DefinitionTable.cs

@@ -37,6 +37,43 @@ public class DefinitionTable
         return Optional.OfNullable(definition);
     }
 
+    public Optional<TraitDefinitionNode> LookupTrait(string @namespace, string name)
+    {
+        var definition = _syntaxTrees
+            .Where(c => c.Namespace == @namespace)
+            .SelectMany(c => c.Definitions)
+            .OfType<TraitDefinitionNode>()
+            .SingleOrDefault(f => f.Name == name);
+
+        return Optional.OfNullable(definition);
+    }
+
+    public Optional<Tuple<TraitImplementationDefinitionNode, ImplementationFuncNode>> LookupTraitImplementationForType(NubType type, string funcName)
+    {
+        var implementations = _syntaxTrees
+            .SelectMany(c => c.Definitions)
+            .OfType<TraitImplementationDefinitionNode>()
+            .Where(c => c.ForType.Equals(type));
+
+        var implementation = implementations.SingleOrDefault(c => c.Functions.Any(x => x.Name == funcName));
+
+        var value = implementation == null ? null : new Tuple<TraitImplementationDefinitionNode, ImplementationFuncNode>(implementation, implementation.Functions.First(x => x.Name == funcName));
+
+        return Optional.OfNullable(value);
+    }
+
+    public Optional<TraitFunc> LookupFunctionOnTrait(string @namespace, string name, string funcName)
+    {
+        var traitDef = LookupTrait(@namespace, name);
+        if (traitDef.HasValue)
+        {
+            var function = traitDef.Value.Functions.SingleOrDefault(x => x.Name == funcName);
+            return Optional.OfNullable(function);
+        }
+
+        return Optional<TraitFunc>.Empty();
+    }
+
     public IEnumerable<StructDefinitionNode> GetStructs()
     {
         return _syntaxTrees
@@ -65,18 +102,18 @@ public class DefinitionTable
             .OfType<ExternFuncDefinitionNode>();
     }
 
-    public IEnumerable<InterfaceDefinitionNode> GetInterfaces()
+    public IEnumerable<TraitDefinitionNode> GetTraits()
     {
         return _syntaxTrees
             .SelectMany(c => c.Definitions)
-            .OfType<InterfaceDefinitionNode>();
+            .OfType<TraitDefinitionNode>();
     }
 
-    public IEnumerable<ImplementationDefinitionNode> GetImplementations()
+    public IEnumerable<TraitImplementationDefinitionNode> GetTraitImplementations()
     {
         return _syntaxTrees
             .SelectMany(c => c.Definitions)
-            .OfType<ImplementationDefinitionNode>();
+            .OfType<TraitImplementationDefinitionNode>();
     }
 }
 
@@ -111,6 +148,43 @@ public class BoundDefinitionTable
         return Optional.OfNullable(definition);
     }
 
+    public Optional<BoundTraitDefinitionNode> LookupTrait(string @namespace, string name)
+    {
+        var definition = _syntaxTrees
+            .Where(c => c.Namespace == @namespace)
+            .SelectMany(c => c.Definitions)
+            .OfType<BoundTraitDefinitionNode>()
+            .SingleOrDefault(f => f.Name == name);
+
+        return Optional.OfNullable(definition);
+    }
+
+    public Optional<Tuple<BoundTraitImplementationDefinitionNode, BoundImplementationFuncNode>> LookupTraitImplementationForType(NubType type, string funcName)
+    {
+        var implementations = _syntaxTrees
+            .SelectMany(c => c.Definitions)
+            .OfType<BoundTraitImplementationDefinitionNode>()
+            .Where(c => c.ForType.Equals(type));
+
+        var implementation = implementations.SingleOrDefault(c => c.Functions.Any(x => x.Name == funcName));
+
+        var value = implementation == null ? null : new Tuple<BoundTraitImplementationDefinitionNode, BoundImplementationFuncNode>(implementation, implementation.Functions.First(x => x.Name == funcName));
+
+        return Optional.OfNullable(value);
+    }
+
+    public Optional<BountTraitFunc> LookupFunctionOnTrait(string @namespace, string name, string funcName)
+    {
+        var traitDef = LookupTrait(@namespace, name);
+        if (traitDef.HasValue)
+        {
+            var function = traitDef.Value.Functions.SingleOrDefault(x => x.Name == funcName);
+            return Optional.OfNullable(function);
+        }
+
+        return Optional<BountTraitFunc>.Empty();
+    }
+
     public IEnumerable<BoundStructDefinitionNode> GetStructs()
     {
         return _syntaxTrees
@@ -139,17 +213,17 @@ public class BoundDefinitionTable
             .OfType<BoundExternFuncDefinitionNode>();
     }
 
-    public IEnumerable<BoundInterfaceDefinitionNode> GetInterfaces()
+    public IEnumerable<BoundTraitDefinitionNode> GetTraits()
     {
         return _syntaxTrees
             .SelectMany(c => c.Definitions)
-            .OfType<BoundInterfaceDefinitionNode>();
+            .OfType<BoundTraitDefinitionNode>();
     }
 
-    public IEnumerable<BoundImplementationDefinitionNode> GetImplementations()
+    public IEnumerable<BoundTraitImplementationDefinitionNode> GetTraitImplementations()
     {
         return _syntaxTrees
             .SelectMany(c => c.Definitions)
-            .OfType<BoundImplementationDefinitionNode>();
+            .OfType<BoundTraitImplementationDefinitionNode>();
     }
 }