protected override void VisitMethodCallSyntax(MethodCallSyntax pNode) { base.VisitMethodCallSyntax(pNode); //We only care about methods that aren't in the current module if (_module != null || Namespace != null) { System.Diagnostics.Debug.Assert(_module != null || _unit.HasReference(Namespace)); //Get the referenced module var mod = Namespace == null ? _module : _unit.GetReference(Namespace); //Find the method foreach (var m in mod.Module.Methods) { if (IsCalledMethod(m, pNode)) { var rn = new ReferencedNode(m, mod.Cache); if (!MethodNodes.Contains(rn)) { MethodNodes.Add(rn); //Get any type/methods that this method references var mrv = new ModuleReferenceVisitor(mod.Cache, _context, mod); mrv.MethodNodes.Add(rn); mrv.Visit(m); MethodNodes.AddRange(mrv.MethodNodes); TypeNodes.AddRange(mrv.TypeNodes); } } } } }
protected override void VisitModuleSyntax(ModuleSyntax pNode) { ////// ////// Discover enums ////// Add enums first since they can't reference anything, but things can reference enums ////// foreach (var e in pNode.Enums) { _unit.AddType(e); } //Build our list for discovering types for (int i = 0; i < pNode.Structs.Count; i++) { var s = pNode.Structs[i]; if (s.DefinitionType == DefinitionTypes.Implement) { var applies = SyntaxHelper.GetFullTypeName(s.AppliesTo); if (!_implements.ContainsKey(applies)) { _implements.Add(applies, new List <TypeDefinitionSyntax>()); } _implements[applies].Add(s); } else { _discoveryGraph.AddNode(s); } } ///// ///// Discover all other types ///// var nodes = _discoveryGraph.GetNodes(); for (int i = 0; i < nodes.Count; i++) { var t = SyntaxHelper.GetFullTypeName(nodes[i].Node.DeclaredType); if (!nodes[i].Permanent && !nodes[i].Temporary && DiscoverTypes(t, nodes[i].Node.Span)) { //If we discover a type go back to the beginning to see if any that were dependent //on this can now be typed i = -1; } } foreach (var i in _implements) { foreach (var s in i.Value) { //Validate that the namespace and type exist var applyName = SyntaxHelper.GetFullTypeName(s.AppliesTo); var name = SyntaxHelper.GetFullTypeName(s.DeclaredType); //Mark any traits for types if (ValidateType(s.AppliesTo.Namespace, applyName, s) && ValidateType(s.DeclaredType.Namespace, name, s)) { var result = _unit.FromString(s.DeclaredType, out SmallType traitType); System.Diagnostics.Debug.Assert(result == Compiler.FindResult.Found); result = _unit.FromString(s.AppliesTo, out SmallType applyType); System.Diagnostics.Debug.Assert(result == Compiler.FindResult.Found); applyType.AddTrait(traitType); TypeDefinitionSyntax trait; if (s.DeclaredType.Namespace == null) { trait = _discoveryGraph.GetNode(name).Node; } else { //TODO clean this up trait = _unit.GetReference(s.DeclaredType.Namespace.Value).Module.Structs.SingleOrDefault((pt) => pt.DeclaredType.Value == s.DeclaredType.Value); } ValidateImplementation(trait, s); } } } // // Add all methods to the MethodCache // for (int j = 0; j < pNode.Methods.Count; j++) { AddMethodToCache(null, pNode.Methods[j], out MethodDefinition m); } // // Add struct methods to MethodCache // foreach (var s in pNode.Structs) { var result = _unit.FromString(s.GetApplicableType(), out SmallType type); //This can occur if we are specifying an undeclared type //or a type imported from another module // - The namespace might not be specified // - The type might not be exported switch (result) { case Compiler.FindResult.IncorrectScope: CompilerErrors.TypeNotInScope(s.GetApplicableType().ToString(), s.Span); break; case Compiler.FindResult.NotFound: CompilerErrors.UndeclaredType(s.GetApplicableType().ToString(), s.Span); break; } //Add each method to the cache and set type constructors if necessary for (int j = 0; j < s.Methods.Count; j++) { if (AddMethodToCache(type, s.Methods[j], out MethodDefinition m) && s.Methods[j].Annotation.Value == KeyAnnotations.Constructor) { type.SetConstructor(m); } } if (!type.HasDefinedConstructor()) { type.SetDefaultConstructor(); } } }