diff --git a/src/AXSharp.compiler/src/AXSharp.Compiler/Core/IxNodeVisitor.cs b/src/AXSharp.compiler/src/AXSharp.Compiler/Core/IxNodeVisitor.cs index 0e2ea424a..d4d6117fb 100644 --- a/src/AXSharp.compiler/src/AXSharp.Compiler/Core/IxNodeVisitor.cs +++ b/src/AXSharp.compiler/src/AXSharp.Compiler/Core/IxNodeVisitor.cs @@ -1,4 +1,4 @@ -// AXSharp.Compiler +// AXSharp.Compiler // Copyright (c) 2023 MTS spol. s r.o., and Contributors. All Rights Reserved. // Contributors: https://github.com/inxton/axsharp/graphs/contributors // See the LICENSE file in the repository root for more information. @@ -34,254 +34,269 @@ namespace AXSharp.Compiler.Core; /// Variables etc). /// /// -public partial class IxNodeVisitor : ISemanticNodeVisitor +public partial class IxNodeVisitor : ISemanticNodeVisitor { - void ISemanticNodeVisitor.Visit(IPartialSemanticTree partialSemanticTree, + Unit ISemanticNodeVisitor.Visit(IPartialSemanticTree partialSemanticTree, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISymbol symbol, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ISymbol symbol, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IPragma pragma, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(IPragma pragma, ICombinedThreeVisitor data) { data.CreatePragma(pragma, data); + return default; } - void ISemanticNodeVisitor.Visit(IConfigurationDeclaration configurationDeclaration, + Unit ISemanticNodeVisitor.Visit(IConfigurationDeclaration configurationDeclaration, ICombinedThreeVisitor data) { data.CreateConfigDeclaration(configurationDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(ITaskConfigurationDeclaration taskConfigurationDeclaration, + Unit ISemanticNodeVisitor.Visit(ITaskConfigurationDeclaration taskConfigurationDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ITaskDeclaration taskDeclaration, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ITaskDeclaration taskDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit( + Unit ISemanticNodeVisitor.Visit( IProgramConfigurationDeclaration programConfigurationDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(INamespaceDeclaration namespaceDeclaration, + Unit ISemanticNodeVisitor.Visit(INamespaceDeclaration namespaceDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IUsingDirective usingDirective, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(IUsingDirective usingDirective, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IProgramDeclaration programDeclaration, + Unit ISemanticNodeVisitor.Visit(IProgramDeclaration programDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IClassDeclaration classDeclaration, + Unit ISemanticNodeVisitor.Visit(IClassDeclaration classDeclaration, ICombinedThreeVisitor data) { data.CreateClassDeclaration(classDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IInterfaceDeclaration interfaceDeclaration, + Unit ISemanticNodeVisitor.Visit(IInterfaceDeclaration interfaceDeclaration, ICombinedThreeVisitor data) { data.CreateInterfaceDeclaration(interfaceDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IFunctionDeclaration functionDeclaration, + Unit ISemanticNodeVisitor.Visit(IFunctionDeclaration functionDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IFunctionBlockDeclaration functionBlockDeclaration, + Unit ISemanticNodeVisitor.Visit(IFunctionBlockDeclaration functionBlockDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IMethodDeclaration methodDeclaration, + Unit ISemanticNodeVisitor.Visit(IMethodDeclaration methodDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - public void Visit(IClassMethodDeclaration methodDeclaration, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(IClassMethodDeclaration methodDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IMethodPrototypeDeclaration methodPrototypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IMethodPrototypeDeclaration methodPrototypeDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IScalarTypeDeclaration scalarTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IScalarTypeDeclaration scalarTypeDeclaration, ICombinedThreeVisitor data) { data.CreateScalarTypeDeclaration(scalarTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IStructuredTypeDeclaration structuredTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IStructuredTypeDeclaration structuredTypeDeclaration, ICombinedThreeVisitor data) { data.CreateStructuredType(structuredTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IArrayTypeDeclaration arrayTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IArrayTypeDeclaration arrayTypeDeclaration, ICombinedThreeVisitor data) { data.CreateArrayTypeDeclaration(arrayTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IEnumTypeDeclaration enumTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IEnumTypeDeclaration enumTypeDeclaration, ICombinedThreeVisitor data) { data.CreateEnumTypeDeclaration(enumTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(INamedValueTypeDeclaration namedValueTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(INamedValueTypeDeclaration namedValueTypeDeclaration, ICombinedThreeVisitor data) { data.CreateNamedValueTypeDeclaration(namedValueTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IReferenceTypeDeclaration referenceTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IReferenceTypeDeclaration referenceTypeDeclaration, ICombinedThreeVisitor data) { data.CreateReferenceToDeclaration(referenceTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IStringTypeDeclaration stringTypeDeclaration, + Unit ISemanticNodeVisitor.Visit(IStringTypeDeclaration stringTypeDeclaration, ICombinedThreeVisitor data) { data.CreateStringTypeDeclaration(stringTypeDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IDimension dimension, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(IDimension dimension, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IFieldDeclaration fieldDeclaration, + Unit ISemanticNodeVisitor.Visit(IFieldDeclaration fieldDeclaration, ICombinedThreeVisitor data) { data.CreateFieldDeclaration(fieldDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IVariableDeclaration variableDeclaration, + Unit ISemanticNodeVisitor.Visit(IVariableDeclaration variableDeclaration, ICombinedThreeVisitor data) { data.CreateVariableDeclaration(variableDeclaration, this); + return default; } - void ISemanticNodeVisitor.Visit(IEnumValueDeclaration enumValueDeclaration, + Unit ISemanticNodeVisitor.Visit(IEnumValueDeclaration enumValueDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(INamedValueDeclaration namedValueDeclaration, + Unit ISemanticNodeVisitor.Visit(INamedValueDeclaration namedValueDeclaration, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticInitializerExpression initializerExpression, + Unit ISemanticNodeVisitor.Visit(ISemanticInitializerExpression initializerExpression, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticArrayInitializer arrayInitializer, + Unit ISemanticNodeVisitor.Visit(ISemanticArrayInitializer arrayInitializer, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticStructureInitializer structureInitializer, + Unit ISemanticNodeVisitor.Visit(ISemanticStructureInitializer structureInitializer, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticMemberInitializer memberInitializer, + Unit ISemanticNodeVisitor.Visit(ISemanticMemberInitializer memberInitializer, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticTypeAccess semanticTypeAccess, + Unit ISemanticNodeVisitor.Visit(ISemanticTypeAccess semanticTypeAccess, ICombinedThreeVisitor data) { data.CreateSemanticTypeAccess(semanticTypeAccess, this); + return default; } - public void Visit(IDocComment semanticTypeAccess, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(IDocComment semanticTypeAccess, ICombinedThreeVisitor data) { data.CreateDocComment(semanticTypeAccess, data); + return default; } - void ISemanticNodeVisitor.Visit(ISemanticInstructionList instrList, + Unit ISemanticNodeVisitor.Visit(ISemanticInstructionList instrList, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticAssignmentInstruction assignment, + Unit ISemanticNodeVisitor.Visit(ISemanticAssignmentInstruction assignment, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticUnsafeAssignmentInstruction assignment, + Unit ISemanticNodeVisitor.Visit(ISemanticUnsafeAssignmentInstruction assignment, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticAssignmentAttemptInstruction assignmentAttempt, + Unit ISemanticNodeVisitor.Visit(ISemanticAssignmentAttemptInstruction assignmentAttempt, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticExpressionInstruction expression, + Unit ISemanticNodeVisitor.Visit(ISemanticExpressionInstruction expression, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticIfConditionalStatement condStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticIfConditionalStatement condStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IConditionalInstructionList condInstrList, + Unit ISemanticNodeVisitor.Visit(IConditionalInstructionList condInstrList, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticCaseStatement caseStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticCaseStatement caseStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); @@ -289,112 +304,112 @@ void ISemanticNodeVisitor.Visit(ISemanticCaseStatement ca - void ISemanticNodeVisitor.Visit(ISemanticSubrange subrange, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ISemanticSubrange subrange, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticForStatement forStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticForStatement forStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticWhileStatement whileStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticWhileStatement whileStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticRepeatStatement repeatStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticRepeatStatement repeatStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticContinueInstruction continueInstruction, + Unit ISemanticNodeVisitor.Visit(ISemanticContinueInstruction continueInstruction, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticExitInstruction exitInstruction, + Unit ISemanticNodeVisitor.Visit(ISemanticExitInstruction exitInstruction, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticReturnStatement returnStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticReturnStatement returnStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticAsmStatement asmStatement, + Unit ISemanticNodeVisitor.Visit(ISemanticAsmStatement asmStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticConstantExpression constExpr, + Unit ISemanticNodeVisitor.Visit(ISemanticConstantExpression constExpr, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticIdentifierAccess identifierAccess, + Unit ISemanticNodeVisitor.Visit(ISemanticIdentifierAccess identifierAccess, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticBinaryExpression binExpr, + Unit ISemanticNodeVisitor.Visit(ISemanticBinaryExpression binExpr, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticUnaryExpression unaryExpression, + Unit ISemanticNodeVisitor.Visit(ISemanticUnaryExpression unaryExpression, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticQualifiedEnumAccess qualifiedEnumAccess, + Unit ISemanticNodeVisitor.Visit(ISemanticQualifiedEnumAccess qualifiedEnumAccess, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticMemberAccessExpression memberAccessExpression, + Unit ISemanticNodeVisitor.Visit(ISemanticMemberAccessExpression memberAccessExpression, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticArrayAccessExpression arrayAccessExpression, + Unit ISemanticNodeVisitor.Visit(ISemanticArrayAccessExpression arrayAccessExpression, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticCallExpression call, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ISemanticCallExpression call, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticParameterList paramList, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ISemanticParameterList paramList, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(ISemanticParameterAssignment paramAssignment, + Unit ISemanticNodeVisitor.Visit(ISemanticParameterAssignment paramAssignment, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - void ISemanticNodeVisitor.Visit(IPartialAccessExpression partialAccessExpression, + Unit ISemanticNodeVisitor.Visit(IPartialAccessExpression partialAccessExpression, ICombinedThreeVisitor data) { throw new NotSupportedException(); @@ -1246,13 +1261,13 @@ void ISyntaxNodeVisitor.Accept(IXOrExpressionSyntax xOrEx #endregion - public void Visit(ISemanticEmptyInstruction emptyInstruction, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ISemanticEmptyInstruction emptyInstruction, ICombinedThreeVisitor data) { throw new NotSupportedException(); } - public void Visit(ISemanticCaseSelectionStatement caseSelectionStatement, ICombinedThreeVisitor data) + Unit ISemanticNodeVisitor.Visit(ISemanticCaseSelectionStatement caseSelectionStatement, ICombinedThreeVisitor data) { throw new NotSupportedException(); } -} \ No newline at end of file +} diff --git a/src/AXSharp.compiler/src/AXSharp.Compiler/Core/Unit.cs b/src/AXSharp.compiler/src/AXSharp.Compiler/Core/Unit.cs new file mode 100644 index 000000000..cf99ec457 --- /dev/null +++ b/src/AXSharp.compiler/src/AXSharp.Compiler/Core/Unit.cs @@ -0,0 +1,42 @@ +// AXSharp.Compiler +// Copyright (c) 2023 MTS spol. s r.o., and Contributors. All Rights Reserved. +// Contributors: https://github.com/inxton/axsharp/graphs/contributors +// See the LICENSE file in the repository root for more information. +// https://github.com/inxton/axsharp/blob/dev/LICENSE +// Third party licenses: https://github.com/inxton/axsharp/blob/master/notices.md + +namespace AXSharp.Compiler.Core; + +/// +/// Represents a void/unit return type for the semantic node visitor pattern. +/// Used as the TResult type parameter when the visitor doesn't need to return a meaningful value. +/// +public readonly struct Unit : IEquatable +{ + /// + /// Gets the single value of the Unit type. + /// + public static readonly Unit Default = default; + + /// + public bool Equals(Unit other) => true; + + /// + public override bool Equals(object? obj) => obj is Unit; + + /// + public override int GetHashCode() => 0; + + /// + public override string ToString() => "()"; + + /// + /// Determines whether two Unit values are equal (always true). + /// + public static bool operator ==(Unit left, Unit right) => true; + + /// + /// Determines whether two Unit values are not equal (always false). + /// + public static bool operator !=(Unit left, Unit right) => false; +} diff --git a/src/AXSharp.compiler/src/AXSharp.Compiler/LegalAcrobatics.cs b/src/AXSharp.compiler/src/AXSharp.Compiler/LegalAcrobatics.cs index 1d6712a93..0bc1f2c1c 100644 --- a/src/AXSharp.compiler/src/AXSharp.Compiler/LegalAcrobatics.cs +++ b/src/AXSharp.compiler/src/AXSharp.Compiler/LegalAcrobatics.cs @@ -46,7 +46,7 @@ private static void SetupAssemblyResolverLegalAcrobatics(string entryAssemblyLoc AXAssemblies = axAssemblies; - StcVersion = AXAssemblies.FirstOrDefault()?.GetName().Version?.ToString(); + StcVersion = AXAssemblies.FirstOrDefault(p => p.GetName().FullName.StartsWith("AX.ST.Semantic"))?.GetName().Version?.ToString(); diff --git a/src/AXSharp.compiler/src/ixc/Program.cs b/src/AXSharp.compiler/src/ixc/Program.cs index 1243206e6..c02340cde 100644 --- a/src/AXSharp.compiler/src/ixc/Program.cs +++ b/src/AXSharp.compiler/src/ixc/Program.cs @@ -111,7 +111,7 @@ private static void DisplayInfo() Console.ForegroundColor = ConsoleColor.Magenta; - Console.WriteLine($"Using version '> {LegalAcrobatics.StcVersion}' of stc."); + Console.WriteLine($"Using version '{LegalAcrobatics.StcVersion}' of stc."); Console.ForegroundColor = originalColor; if (int.Parse(GitVersionInformation.Major) < 1 || string.IsNullOrEmpty(GitVersionInformation.PreReleaseLabel)) diff --git a/src/AXSharp.compiler/src/ixd/Helpers/YamlHelpers.cs b/src/AXSharp.compiler/src/ixd/Helpers/YamlHelpers.cs index 03d82ef24..a96f26189 100644 --- a/src/AXSharp.compiler/src/ixd/Helpers/YamlHelpers.cs +++ b/src/AXSharp.compiler/src/ixd/Helpers/YamlHelpers.cs @@ -205,7 +205,7 @@ private string GetTextFromXml(XmlNode element, PropertyInfo? prop) } //create toc schema, grouped if namespace exists, or only global - public void AddToTocSchema(MyNodeVisitor visitor, TocSchema.Item tocSchemaItem, string? tocGroup) + public void AddToTocSchema(DocNodeVisitor visitor, TocSchema.Item tocSchemaItem, string? tocGroup) { if (tocGroup == null || tocGroup == "" || tocGroup == "$GLOBAL") { @@ -255,7 +255,7 @@ public string GetAssembly(string projectFile) } //add references of inherited members - public void AddReferences(string[] references, MyNodeVisitor v) + public void AddReferences(string[] references, DocNodeVisitor v) { foreach (var member in references) { @@ -300,7 +300,7 @@ public Reference CreateNamespaceReference(IDeclaration declaration) }; } //add general reference - public void AddReference(IDeclaration declaration, MyNodeVisitor v) + public void AddReference(IDeclaration declaration, DocNodeVisitor v) { if (v.YamlHelper.References.Where(a => a.Uid == Helpers.GetBaseUid(declaration)).Count() > 0) return; diff --git a/src/AXSharp.compiler/src/ixd/Interfaces/IYamlBuiderVisitor.cs b/src/AXSharp.compiler/src/ixd/Interfaces/IYamlBuiderVisitor.cs index db697b42d..637a8e7e7 100644 --- a/src/AXSharp.compiler/src/ixd/Interfaces/IYamlBuiderVisitor.cs +++ b/src/AXSharp.compiler/src/ixd/Interfaces/IYamlBuiderVisitor.cs @@ -19,91 +19,91 @@ public interface IYamlBuiderVisitor /// /// File syntax node. /// Associated visitor. - public virtual void CreateFile(IFileSyntax fileSyntax, MyNodeVisitor visitor) + public virtual void CreateFile(IFileSyntax fileSyntax, DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateNamespaceYaml( INamespaceDeclaration namespaceDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateClassYaml( IClassDeclaration classDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateFieldYaml( IFieldDeclaration fieldDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateMethodYaml( IMethodDeclaration methodDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateNamedValueTypeYaml( INamedValueTypeDeclaration namedValueTypeDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateEnumTypeYaml( IEnumTypeDeclaration enumTypeDeclaration, - MyNodeVisitor myNodeVisitor) + DocNodeVisitor myNodeVisitor) { throw new NotImplementedException(); } void CreateNamedValueYaml( INamedValueDeclaration namedValueDeclaration, - MyNodeVisitor myNodeVisitor) + DocNodeVisitor myNodeVisitor) { throw new NotImplementedException(); } void CreateEnumValueYaml( IEnumValueDeclaration enumValueDeclaration, - MyNodeVisitor myNodeVisitor) + DocNodeVisitor myNodeVisitor) { throw new NotImplementedException(); } public virtual void CreateInterfaceYaml( IInterfaceDeclaration InterfaceDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateMethodPrototypeYaml( IMethodPrototypeDeclaration methodPrototypeDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } public virtual void CreateFunctionYaml( IFunctionDeclaration functionDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } void CreateStructuredTypeYaml( IStructuredTypeDeclaration structuredTypeDeclaration, - MyNodeVisitor visitor) + DocNodeVisitor visitor) { throw new NotImplementedException(); } diff --git a/src/AXSharp.compiler/src/ixd/Program.cs b/src/AXSharp.compiler/src/ixd/Program.cs index fe6ebfc28..8cf16f516 100644 --- a/src/AXSharp.compiler/src/ixd/Program.cs +++ b/src/AXSharp.compiler/src/ixd/Program.cs @@ -82,7 +82,7 @@ void GenerateYamls(Options o) var semanticTree = compilation.Compilation.GetSemanticTree(); //visit - var myNodeVisitor = new MyNodeVisitor(); + var myNodeVisitor = new DocNodeVisitor(); var yamlSerializer = new YamlSerializer(o); var treeWalker = new YamlBuilder(yamlSerializer); diff --git a/src/AXSharp.compiler/src/ixd/Visitors/DocNodeVisitor.cs b/src/AXSharp.compiler/src/ixd/Visitors/DocNodeVisitor.cs new file mode 100644 index 000000000..25443a1d7 --- /dev/null +++ b/src/AXSharp.compiler/src/ixd/Visitors/DocNodeVisitor.cs @@ -0,0 +1,428 @@ +using AX.ST.Semantic; +using AX.ST.Semantic.Model; +using AX.ST.Semantic.Model.Declarations; +using AX.ST.Semantic.Model.Declarations.Types; +using AX.ST.Semantic.Model.Init; +using AX.ST.Semantic.Pragmas; +using AX.ST.Semantic.Symbols; +using AX.ST.Semantic.Tree; +using AX.ST.Syntax.Tree; +using AX.Text; +using AXSharp.Compiler.Core; +using AXSharp.ixc_doc.Helpers; +using AXSharp.ixc_doc.Interfaces; +using AXSharp.ixc_doc.Schemas; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace AXSharp.ixc_doc.Visitors +{ + + //semantic + public partial class DocNodeVisitor : ISemanticNodeVisitor + { + public YamlSerializerHelper YamlHelper { get; set; } + //public Compiler.AxProject axProject { get; set; } + + public DocNodeVisitor(Compiler.AxProject? axProject = null) + { + //this.axProject = axProject; + YamlHelper = new YamlSerializerHelper(); + } + + public void MapYamlHelperToSchema() + { + YamlHelper.Schema.Items = YamlHelper.Items.ToList(); + YamlHelper.Schema.References = YamlHelper.References.ToArray(); + } + + public Unit Visit(IPartialSemanticTree partialSemanticTree, IYamlBuiderVisitor data) + { + partialSemanticTree.ChildNodes.Where(p => p is INamespaceDeclaration).ToList().ForEach(p => p.Accept(this, data)); + return default; + } + + public Unit Visit(ISymbol symbol, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IPragma pragma, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IConfigurationDeclaration configurationDeclaration, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ITaskConfigurationDeclaration taskConfigurationDeclaration, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ITaskDeclaration taskDeclaration, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IProgramConfigurationDeclaration programConfigurationDeclaration, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(INamespaceDeclaration namespaceDeclaration, IYamlBuiderVisitor data) + { + data.CreateNamespaceYaml(namespaceDeclaration, this); + return default; + } + + public Unit Visit(IUsingDirective usingDirective, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IProgramDeclaration programDeclaration, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IClassDeclaration classDeclaration, IYamlBuiderVisitor data) + { + data.CreateClassYaml(classDeclaration, this); + return default; + } + + public Unit Visit(IInterfaceDeclaration interfaceDeclaration, IYamlBuiderVisitor data) + { + data.CreateInterfaceYaml(interfaceDeclaration, this); + return default; + } + + public Unit Visit(IFunctionDeclaration functionDeclaration, IYamlBuiderVisitor data) + { + data.CreateFunctionYaml(functionDeclaration, this); + return default; + } + + public Unit Visit(IFunctionBlockDeclaration functionBlockDeclaration, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IMethodDeclaration methodDeclaration, IYamlBuiderVisitor data) + { + data.CreateMethodYaml(methodDeclaration, this); + return default; + } + + public Unit Visit(IClassMethodDeclaration methodDeclaration, IYamlBuiderVisitor data) + { + data.CreateMethodYaml(methodDeclaration, this); + return default; + } + + public Unit Visit(IMethodPrototypeDeclaration methodPrototypeDeclaration, IYamlBuiderVisitor data) + { + data.CreateMethodPrototypeYaml(methodPrototypeDeclaration, this); + return default; + } + + public Unit Visit(IScalarTypeDeclaration scalarType, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IStructuredTypeDeclaration structuredTypeDeclaration, IYamlBuiderVisitor data) + { + data.CreateStructuredTypeYaml(structuredTypeDeclaration, this); + return default; + } + + public Unit Visit(IArrayTypeDeclaration arrayTypeDeclaration, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IEnumTypeDeclaration enumTypeDeclaration, IYamlBuiderVisitor data) + { + data.CreateEnumTypeYaml(enumTypeDeclaration, this); + return default; + } + + public Unit Visit(INamedValueTypeDeclaration namedValueTypeDeclaration, IYamlBuiderVisitor data) + { + data.CreateNamedValueTypeYaml(namedValueTypeDeclaration, this); + return default; + } + + public Unit Visit(IReferenceTypeDeclaration referenceTypeDeclaration, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IStringTypeDeclaration stringTypeDeclaration, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IDimension dimension, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IFieldDeclaration fieldDeclaration, IYamlBuiderVisitor data) + { + data.CreateFieldYaml(fieldDeclaration, this); + return default; + } + + public Unit Visit(IVariableDeclaration variableDeclaration, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(IEnumValueDeclaration enumValueDeclaration, IYamlBuiderVisitor data) + { + data.CreateEnumValueYaml(enumValueDeclaration, this); + return default; + } + + public Unit Visit(INamedValueDeclaration namedValueDeclaration, IYamlBuiderVisitor data) + { + data.CreateNamedValueYaml(namedValueDeclaration, this); + return default; + } + + public Unit Visit(ISemanticInitializerExpression initializerExpression, IYamlBuiderVisitor data) + { + return default; + } + + public Unit Visit(ISemanticArrayInitializer arrayInitializer, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticStructureInitializer structureInitializer, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticMemberInitializer memberInitializer, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticTypeAccess semanticTypeAccess, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IDocComment semanticTypeAccess, IYamlBuiderVisitor data) + { + // throw new NotImplementedException(); + return default; + + return default; + } + + public Unit Visit(ISemanticInstructionList instrList, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticEmptyInstruction emptyInstruction, IYamlBuiderVisitor data) + { + // throw new NotImplementedException(); + return default; + + return default; + } + + public Unit Visit(ISemanticAssignmentInstruction assignment, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticUnsafeAssignmentInstruction assignment, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticAssignmentAttemptInstruction assignmentAttempt, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticExpressionInstruction expression, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticIfConditionalStatement condStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IConditionalInstructionList condInstrList, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticCaseStatement caseStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticCaseSelectionStatement caseSelectionStatement, IYamlBuiderVisitor data) + { + throw new NotImplementedException(); + } + + //public Unit Visit(ISemanticCaseSelection caseSelection, IYamlBuiderVisitor data) + //{ + + //} + + public Unit Visit(ISemanticSubrange subrange, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticForStatement forStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticWhileStatement whileStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticRepeatStatement repeatStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticContinueInstruction continueInstruction, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticExitInstruction exitInstruction, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticReturnStatement returnStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticAsmStatement asmStatement, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticConstantExpression constExpr, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticIdentifierAccess identifierAccess, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticBinaryExpression binExpr, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticUnaryExpression unaryExpression, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticQualifiedEnumAccess qualifiedEnumAccess, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticMemberAccessExpression memberAccessExpression, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticArrayAccessExpression arrayAccessExpression, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticCallExpression call, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticParameterList paramList, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(ISemanticParameterAssignment paramAssignment, IYamlBuiderVisitor data) + { + + return default; + } + + public Unit Visit(IPartialAccessExpression partialAccessExpression, IYamlBuiderVisitor data) + { + + return default; + } + + } + +} diff --git a/src/AXSharp.compiler/src/ixd/Visitors/MyNodeVisitor.cs b/src/AXSharp.compiler/src/ixd/Visitors/MyNodeVisitor.cs deleted file mode 100644 index bfc86947c..000000000 --- a/src/AXSharp.compiler/src/ixd/Visitors/MyNodeVisitor.cs +++ /dev/null @@ -1,360 +0,0 @@ -using AX.ST.Semantic; -using AX.ST.Semantic.Model; -using AX.ST.Semantic.Model.Declarations; -using AX.ST.Semantic.Model.Declarations.Types; -using AX.ST.Semantic.Model.Init; -using AX.ST.Semantic.Pragmas; -using AX.ST.Semantic.Symbols; -using AX.ST.Semantic.Tree; -using AX.ST.Syntax.Tree; -using AX.Text; -using AXSharp.ixc_doc.Helpers; -using AXSharp.ixc_doc.Interfaces; -using AXSharp.ixc_doc.Schemas; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace AXSharp.ixc_doc.Visitors -{ - - //semantic - public partial class MyNodeVisitor : ISemanticNodeVisitor - { - public YamlSerializerHelper YamlHelper { get; set; } - //public Compiler.AxProject axProject { get; set; } - - public MyNodeVisitor(Compiler.AxProject? axProject = null) - { - //this.axProject = axProject; - YamlHelper = new YamlSerializerHelper(); - } - - public void MapYamlHelperToSchema() - { - YamlHelper.Schema.Items = YamlHelper.Items.ToList(); - YamlHelper.Schema.References = YamlHelper.References.ToArray(); - } - - public void Visit(IPartialSemanticTree partialSemanticTree, IYamlBuiderVisitor data) - { - partialSemanticTree.ChildNodes.Where(p => p is INamespaceDeclaration).ToList().ForEach(p => p.Accept(this, data)); - } - - public void Visit(ISymbol symbol, IYamlBuiderVisitor data) - { - - } - - public void Visit(IPragma pragma, IYamlBuiderVisitor data) - { - - } - - public void Visit(IConfigurationDeclaration configurationDeclaration, IYamlBuiderVisitor data) - { - - } - - public void Visit(ITaskConfigurationDeclaration taskConfigurationDeclaration, IYamlBuiderVisitor data) - { - - } - - public void Visit(ITaskDeclaration taskDeclaration, IYamlBuiderVisitor data) - { - - } - - public void Visit(IProgramConfigurationDeclaration programConfigurationDeclaration, IYamlBuiderVisitor data) - { - - } - - public void Visit(INamespaceDeclaration namespaceDeclaration, IYamlBuiderVisitor data) - { - data.CreateNamespaceYaml(namespaceDeclaration, this); - } - - public void Visit(IUsingDirective usingDirective, IYamlBuiderVisitor data) - { - - } - - public void Visit(IProgramDeclaration programDeclaration, IYamlBuiderVisitor data) - { - } - - public void Visit(IClassDeclaration classDeclaration, IYamlBuiderVisitor data) - { - data.CreateClassYaml(classDeclaration, this); - } - - public void Visit(IInterfaceDeclaration interfaceDeclaration, IYamlBuiderVisitor data) - { - data.CreateInterfaceYaml(interfaceDeclaration, this); - } - - public void Visit(IFunctionDeclaration functionDeclaration, IYamlBuiderVisitor data) - { - data.CreateFunctionYaml(functionDeclaration, this); - } - - public void Visit(IFunctionBlockDeclaration functionBlockDeclaration, IYamlBuiderVisitor data) - { - - } - - public void Visit(IMethodDeclaration methodDeclaration, IYamlBuiderVisitor data) - { - data.CreateMethodYaml(methodDeclaration, this); - } - - public void Visit(IClassMethodDeclaration methodDeclaration, IYamlBuiderVisitor data) - { - data.CreateMethodYaml(methodDeclaration, this); - } - - public void Visit(IMethodPrototypeDeclaration methodPrototypeDeclaration, IYamlBuiderVisitor data) - { - data.CreateMethodPrototypeYaml(methodPrototypeDeclaration, this); - } - - public void Visit(IScalarTypeDeclaration scalarType, IYamlBuiderVisitor data) - { - } - - public void Visit(IStructuredTypeDeclaration structuredTypeDeclaration, IYamlBuiderVisitor data) - { - data.CreateStructuredTypeYaml(structuredTypeDeclaration, this); - } - - public void Visit(IArrayTypeDeclaration arrayTypeDeclaration, IYamlBuiderVisitor data) - { - } - - public void Visit(IEnumTypeDeclaration enumTypeDeclaration, IYamlBuiderVisitor data) - { - data.CreateEnumTypeYaml(enumTypeDeclaration, this); - } - - public void Visit(INamedValueTypeDeclaration namedValueTypeDeclaration, IYamlBuiderVisitor data) - { - data.CreateNamedValueTypeYaml(namedValueTypeDeclaration, this); - } - - public void Visit(IReferenceTypeDeclaration referenceTypeDeclaration, IYamlBuiderVisitor data) - { - } - - public void Visit(IStringTypeDeclaration stringTypeDeclaration, IYamlBuiderVisitor data) - { - } - - public void Visit(IDimension dimension, IYamlBuiderVisitor data) - { - } - - public void Visit(IFieldDeclaration fieldDeclaration, IYamlBuiderVisitor data) - { - data.CreateFieldYaml(fieldDeclaration, this); - } - - public void Visit(IVariableDeclaration variableDeclaration, IYamlBuiderVisitor data) - { - } - - public void Visit(IEnumValueDeclaration enumValueDeclaration, IYamlBuiderVisitor data) - { - data.CreateEnumValueYaml(enumValueDeclaration, this); - } - - public void Visit(INamedValueDeclaration namedValueDeclaration, IYamlBuiderVisitor data) - { - data.CreateNamedValueYaml(namedValueDeclaration, this); - } - - public void Visit(ISemanticInitializerExpression initializerExpression, IYamlBuiderVisitor data) - { - } - - public void Visit(ISemanticArrayInitializer arrayInitializer, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticStructureInitializer structureInitializer, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticMemberInitializer memberInitializer, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticTypeAccess semanticTypeAccess, IYamlBuiderVisitor data) - { - - } - - public void Visit(IDocComment semanticTypeAccess, IYamlBuiderVisitor data) - { - // throw new NotImplementedException(); - } - - public void Visit(ISemanticInstructionList instrList, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticEmptyInstruction emptyInstruction, IYamlBuiderVisitor data) - { - // throw new NotImplementedException(); - } - - public void Visit(ISemanticAssignmentInstruction assignment, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticUnsafeAssignmentInstruction assignment, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticAssignmentAttemptInstruction assignmentAttempt, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticExpressionInstruction expression, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticIfConditionalStatement condStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(IConditionalInstructionList condInstrList, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticCaseStatement caseStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticCaseSelectionStatement caseSelectionStatement, IYamlBuiderVisitor data) - { - throw new NotImplementedException(); - } - - //public void Visit(ISemanticCaseSelection caseSelection, IYamlBuiderVisitor data) - //{ - - //} - - public void Visit(ISemanticSubrange subrange, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticForStatement forStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticWhileStatement whileStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticRepeatStatement repeatStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticContinueInstruction continueInstruction, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticExitInstruction exitInstruction, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticReturnStatement returnStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticAsmStatement asmStatement, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticConstantExpression constExpr, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticIdentifierAccess identifierAccess, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticBinaryExpression binExpr, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticUnaryExpression unaryExpression, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticQualifiedEnumAccess qualifiedEnumAccess, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticMemberAccessExpression memberAccessExpression, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticArrayAccessExpression arrayAccessExpression, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticCallExpression call, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticParameterList paramList, IYamlBuiderVisitor data) - { - - } - - public void Visit(ISemanticParameterAssignment paramAssignment, IYamlBuiderVisitor data) - { - - } - - public void Visit(IPartialAccessExpression partialAccessExpression, IYamlBuiderVisitor data) - { - - } - - } - -} diff --git a/src/AXSharp.compiler/src/ixd/Visitors/YamlBuilder.cs b/src/AXSharp.compiler/src/ixd/Visitors/YamlBuilder.cs index e741f4535..5b56657ad 100644 --- a/src/AXSharp.compiler/src/ixd/Visitors/YamlBuilder.cs +++ b/src/AXSharp.compiler/src/ixd/Visitors/YamlBuilder.cs @@ -35,7 +35,7 @@ internal YamlBuilder(YamlSerializer serializer) _s = serializer; } - public virtual void CreateNamespaceYaml(INamespaceDeclaration namespaceDeclaration, MyNodeVisitor v) + public virtual void CreateNamespaceYaml(INamespaceDeclaration namespaceDeclaration, DocNodeVisitor v) { // create toc item var tocSchemaItem = new TocSchema.Item(namespaceDeclaration, namespaceDeclaration.Name); @@ -84,7 +84,7 @@ public virtual void CreateNamespaceYaml(INamespaceDeclaration namespaceDeclarati } //operation on semantic tree - public virtual void CreateClassYaml(IClassDeclaration classDeclaration, MyNodeVisitor v) + public virtual void CreateClassYaml(IClassDeclaration classDeclaration, DocNodeVisitor v) { var item = _mp.PopulateItem(classDeclaration); @@ -120,14 +120,14 @@ public virtual void CreateClassYaml(IClassDeclaration classDeclaration, MyNodeVi } //operation on semantic tree - public virtual void CreateFieldYaml(IFieldDeclaration fieldDeclaration, MyNodeVisitor visitor) + public virtual void CreateFieldYaml(IFieldDeclaration fieldDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(fieldDeclaration); visitor.YamlHelper.Items.Add(item); _yh.AddReference(fieldDeclaration.Type, visitor); } - public virtual void CreateMethodYaml(IMethodDeclaration methodDeclaration, MyNodeVisitor visitor) + public virtual void CreateMethodYaml(IMethodDeclaration methodDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(methodDeclaration); visitor.YamlHelper.Items.Add(item); @@ -144,7 +144,7 @@ public virtual void CreateMethodYaml(IMethodDeclaration methodDeclaration, MyNod } } - public virtual void CreateNamedValueTypeYaml(INamedValueTypeDeclaration namedValueTypeDeclaration, MyNodeVisitor visitor) + public virtual void CreateNamedValueTypeYaml(INamedValueTypeDeclaration namedValueTypeDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(namedValueTypeDeclaration); visitor.YamlHelper.Items.Add(item); @@ -166,7 +166,7 @@ public virtual void CreateNamedValueTypeYaml(INamedValueTypeDeclaration namedVal visitor.YamlHelper.References.Clear(); } - public virtual void CreateEnumTypeYaml(IEnumTypeDeclaration enumTypeDeclaration, MyNodeVisitor visitor) + public virtual void CreateEnumTypeYaml(IEnumTypeDeclaration enumTypeDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(enumTypeDeclaration); visitor.YamlHelper.Items.Add(item); @@ -188,21 +188,21 @@ public virtual void CreateEnumTypeYaml(IEnumTypeDeclaration enumTypeDeclaration, visitor.YamlHelper.References.Clear(); } - public virtual void CreateNamedValueYaml(INamedValueDeclaration namedValueDeclaration, MyNodeVisitor visitor) + public virtual void CreateNamedValueYaml(INamedValueDeclaration namedValueDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(namedValueDeclaration); visitor.YamlHelper.Items.Add(item); _yh.AddReference(namedValueDeclaration.Type, visitor); } - public virtual void CreateEnumValueYaml(IEnumValueDeclaration enumValueDeclaration, MyNodeVisitor visitor) + public virtual void CreateEnumValueYaml(IEnumValueDeclaration enumValueDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(enumValueDeclaration); visitor.YamlHelper.Items.Add(item); _yh.AddReference(enumValueDeclaration.Type, visitor); } - public virtual void CreateInterfaceYaml(IInterfaceDeclaration interfaceDeclaration, MyNodeVisitor v) + public virtual void CreateInterfaceYaml(IInterfaceDeclaration interfaceDeclaration, DocNodeVisitor v) { var item = _mp.PopulateItem(interfaceDeclaration); v.YamlHelper.Items.Add(item); @@ -233,7 +233,7 @@ public virtual void CreateInterfaceYaml(IInterfaceDeclaration interfaceDeclarati v.YamlHelper.References.Clear(); } - public virtual void CreateMethodPrototypeYaml(IMethodPrototypeDeclaration methodPrototypeDeclaration, MyNodeVisitor visitor) + public virtual void CreateMethodPrototypeYaml(IMethodPrototypeDeclaration methodPrototypeDeclaration, DocNodeVisitor visitor) { var item = _mp.PopulateItem(methodPrototypeDeclaration); visitor.YamlHelper.Items.Add(item); @@ -251,7 +251,7 @@ public virtual void CreateMethodPrototypeYaml(IMethodPrototypeDeclaration method } } - public virtual void CreateFunctionYaml(IFunctionDeclaration functionDeclaration, MyNodeVisitor v) + public virtual void CreateFunctionYaml(IFunctionDeclaration functionDeclaration, DocNodeVisitor v) { var item = _mp.PopulateItem(functionDeclaration); v.YamlHelper.Items.Add(item); @@ -313,7 +313,7 @@ private void UpdateNamespaceChildrenAndReferences(INamespaceDeclaration namespac wrapper.NamespaceItem.Children.AddRange(wrapper.NamespaceTemporaryChildren); } - public virtual void CreateStructuredTypeYaml(IStructuredTypeDeclaration structuredTypeDeclaration, MyNodeVisitor v) + public virtual void CreateStructuredTypeYaml(IStructuredTypeDeclaration structuredTypeDeclaration, DocNodeVisitor v) { var item = _mp.PopulateItem(structuredTypeDeclaration); diff --git a/src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/Cs/PragmasExtensionsTests.cs b/src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/Cs/PragmasExtensionsTests.cs index c3ab27cf1..2af4f7d76 100644 --- a/src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/Cs/PragmasExtensionsTests.cs +++ b/src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/Cs/PragmasExtensionsTests.cs @@ -253,7 +253,7 @@ public PragmaMock(string content) public IEnumerable ChildNodes => throw new NotImplementedException(); - public void Accept(ISemanticNodeVisitor visitor, T data) + public TResult Accept(ISemanticNodeVisitor visitor, TContext data) { throw new NotImplementedException(); } diff --git a/src/AXSharp.compiler/tests/AXSharp.CompilerTests/Core/IxNodeVisitorTests.cs b/src/AXSharp.compiler/tests/AXSharp.CompilerTests/Core/IxNodeVisitorTests.cs index 8c9c523da..ac4989750 100644 --- a/src/AXSharp.compiler/tests/AXSharp.CompilerTests/Core/IxNodeVisitorTests.cs +++ b/src/AXSharp.compiler/tests/AXSharp.CompilerTests/Core/IxNodeVisitorTests.cs @@ -43,7 +43,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithPartia var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(partialSemanticTree, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(partialSemanticTree, data)); // Assert @@ -52,13 +52,13 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithPartia [Fact] public void CannotCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithPartialSemanticTreeAndDataWithNullPartialSemanticTree() { - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(default(IPartialSemanticTree), new Mock().Object)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(default(IPartialSemanticTree), new Mock().Object)); } [Fact] public void CannotCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithPartialSemanticTreeAndDataWithNullData() { - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(new Mock().Object, default(ICombinedThreeVisitor))); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(new Mock().Object, default(ICombinedThreeVisitor))); } [Fact] @@ -69,7 +69,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithSymbol var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(symbol, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(symbol, data)); } @@ -82,7 +82,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithPragma var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(pragma, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(pragma, data.Object); // Assert data.Verify(p => p.CreatePragma(pragma, data.Object), Times.Once); @@ -98,7 +98,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithConfig var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(configurationDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(configurationDeclaration, data.Object); // Assert data.Verify(p => p.CreateConfigDeclaration(configurationDeclaration, testClass.Object), Times.Once); @@ -113,7 +113,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithTaskCo var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(taskConfigurationDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(taskConfigurationDeclaration, data)); @@ -128,7 +128,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithTaskDe var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(taskDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(taskDeclaration, data)); } @@ -140,7 +140,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithProgra var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(programConfigurationDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(programConfigurationDeclaration, data)); @@ -154,7 +154,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithNamesp var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(namespaceDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(namespaceDeclaration, data)); @@ -170,7 +170,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithUsingD var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(usingDirective, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(usingDirective, data)); @@ -184,7 +184,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithProgra var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(programDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(programDeclaration, data)); @@ -199,7 +199,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithClassD var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(classDeclaration.Object, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(classDeclaration.Object, data.Object); // Assert data.Verify(p => p.CreateClassDeclaration(classDeclaration.Object, testClass.Object), Times.Once); @@ -216,7 +216,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithInterf // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(interfaceDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(interfaceDeclaration, data.Object); // Assert data.Verify(p => p.CreateInterfaceDeclaration(interfaceDeclaration, testClass.Object), Times.Once); @@ -231,7 +231,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithFuncti var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(functionDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(functionDeclaration, data)); @@ -246,7 +246,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithFuncti var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(functionBlockDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(functionBlockDeclaration, data)); @@ -260,7 +260,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithMethod var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(methodDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(methodDeclaration, data)); @@ -275,7 +275,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithMethod var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(methodPrototypeDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(methodPrototypeDeclaration, data)); @@ -291,7 +291,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithScalar var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(scalarTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(scalarTypeDeclaration, data.Object); // Assert data.Verify(p => p.CreateScalarTypeDeclaration(scalarTypeDeclaration, testClass.Object), Times.Once); @@ -307,7 +307,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithStruct var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(structuredTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(structuredTypeDeclaration, data.Object); // Assert data.Verify(p => p.CreateStructuredType(structuredTypeDeclaration, testClass.Object), Times.Once); @@ -323,7 +323,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithArrayT var data = testClass.As(); // new Mock(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(arrayTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(arrayTypeDeclaration, data.Object); // Assert @@ -341,7 +341,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithEnumTy // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(enumTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(enumTypeDeclaration, data.Object); // Assert data.Verify(p => p.CreateEnumTypeDeclaration(enumTypeDeclaration, testClass.Object), Times.Once); @@ -357,7 +357,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithNamedV var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(namedValueTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(namedValueTypeDeclaration, data.Object); // Assert data.Verify(p => p.CreateNamedValueTypeDeclaration(namedValueTypeDeclaration, testClass.Object), Times.Once); @@ -376,7 +376,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithRefere var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(referenceTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(referenceTypeDeclaration, data.Object); // Assert data.Verify(p => p.CreateReferenceToDeclaration(referenceTypeDeclaration, testClass.Object), Times.Once); @@ -393,7 +393,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithString var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(stringTypeDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(stringTypeDeclaration, data.Object); // Assert data.Verify(p => p.CreateStringTypeDeclaration(stringTypeDeclaration, testClass.Object), Times.Once); @@ -409,7 +409,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithDimens var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(dimension, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(dimension, data)); // Assert @@ -426,7 +426,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithFieldD var data = testClass.As(); // new Mock(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(fieldDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(fieldDeclaration, data.Object); // Assert data.Verify(p => p.CreateFieldDeclaration(fieldDeclaration, testClass.Object), Times.Once); @@ -443,7 +443,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithVariab var data = testClass.As(); // new Mock(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(variableDeclaration, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(variableDeclaration, data.Object); // Assert data.Verify(p => p.CreateVariableDeclaration(variableDeclaration, testClass.Object), Times.Once); @@ -459,7 +459,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithEnumVa var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(enumValueDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(enumValueDeclaration, data)); // Assert @@ -474,7 +474,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithNamedV var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(namedValueDeclaration, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(namedValueDeclaration, data)); // Assert @@ -489,7 +489,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithInitia var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(initializerExpression, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(initializerExpression, data)); // Assert @@ -505,7 +505,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithArrayI var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(arrayInitializer, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(arrayInitializer, data)); // Assert @@ -520,7 +520,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithStruct var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(structureInitializer, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(structureInitializer, data)); // Assert @@ -535,7 +535,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithMember var data = new Mock().Object; // Act - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(memberInitializer, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(memberInitializer, data)); // Assert @@ -552,7 +552,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithSemant var data = testClass.As(); // Act - ((ISemanticNodeVisitor)testClass.Object).Visit(semanticTypeAccess, data.Object); + ((ISemanticNodeVisitor)testClass.Object).Visit(semanticTypeAccess, data.Object); // Assert data.Verify(p => p.CreateSemanticTypeAccess(semanticTypeAccess, testClass.Object), Times.Once); @@ -568,7 +568,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithInstrL var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(instrList, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(instrList, data)); @@ -584,7 +584,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithISeman var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(assignment, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(assignment, data)); @@ -600,7 +600,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithISeman var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(assignment, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(assignment, data)); @@ -615,7 +615,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithAssign var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(assignmentAttempt, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(assignmentAttempt, data)); @@ -630,7 +630,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithExpres var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(expression, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(expression, data)); @@ -645,7 +645,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithCondSt var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(condStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(condStatement, data)); @@ -661,7 +661,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithCondIn var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(condInstrList, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(condInstrList, data)); @@ -677,7 +677,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithCaseSt var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(caseStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(caseStatement, data)); @@ -693,7 +693,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithCaseSt // var data = new Mock().Object; // // Assert - // Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(caseSelection, data)); + // Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(caseSelection, data)); @@ -709,7 +709,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithSubran var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(subrange, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(subrange, data)); @@ -725,7 +725,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithForSta var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(forStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(forStatement, data)); @@ -741,7 +741,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithWhileS var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(whileStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(whileStatement, data)); @@ -757,7 +757,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithRepeat var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(repeatStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(repeatStatement, data)); @@ -773,7 +773,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithContin var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(continueInstruction, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(continueInstruction, data)); @@ -789,7 +789,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithExitIn var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(exitInstruction, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(exitInstruction, data)); @@ -805,7 +805,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithReturn var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(returnStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(returnStatement, data)); @@ -821,7 +821,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithAsmSta var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(asmStatement, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(asmStatement, data)); @@ -836,7 +836,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithConstE var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(constExpr, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(constExpr, data)); @@ -851,7 +851,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithIdenti var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(identifierAccess, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(identifierAccess, data)); @@ -867,7 +867,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithBinExp var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(binExpr, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(binExpr, data)); @@ -883,7 +883,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithUnaryE var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(unaryExpression, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(unaryExpression, data)); @@ -899,7 +899,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithQualif var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(qualifiedEnumAccess, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(qualifiedEnumAccess, data)); @@ -915,7 +915,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithMember var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(memberAccessExpression, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(memberAccessExpression, data)); @@ -933,7 +933,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithArrayA // Assert Assert.Throws( - () => ((ISemanticNodeVisitor)_testClass).Visit(arrayAccessExpression, data)); + () => ((ISemanticNodeVisitor)_testClass).Visit(arrayAccessExpression, data)); } @@ -947,7 +947,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithCallAn var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(call, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(call, data)); @@ -963,7 +963,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithParamL var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(paramList, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(paramList, data)); } @@ -978,7 +978,7 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithParamA var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(paramAssignment, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(paramAssignment, data)); @@ -994,10 +994,10 @@ public void CanCallVisitForISemanticNodeVisitor_ICombinedThreeVisitor_WithPartia var data = new Mock().Object; // Assert - Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(partialAccessExpression, data)); + Assert.Throws(() => ((ISemanticNodeVisitor)_testClass).Visit(partialAccessExpression, data)); } } -} \ No newline at end of file +} diff --git a/src/apax/apax-lock.json b/src/apax/apax-lock.json index 859005791..bed62ad51 100644 --- a/src/apax/apax-lock.json +++ b/src/apax/apax-lock.json @@ -7,56 +7,56 @@ "name": "s", "version": "0.0.0", "devDependencies": { - "@ax/stc": "9.1.36" + "@ax/stc": "11.1.55" } }, "packages": { + "@ax/st-docs": { + "name": "@ax/st-docs", + "version": "11.1.55", + "integrity": "sha512-zHxPk+/FpaL/pXZqwlKDMUWmieSzMQpIPLnfs7Uer51S4gV+5xvwKrc5/9QR050ZcgzDV8MiqzJPFH+Cnz49gQ==", + "resolved": "https://registry.simatic-ax.siemens.io/@ax/st-docs/-/st-docs-11.1.55.tgz", + "dependencies": {} + }, "@ax/stc": { "name": "@ax/stc", - "version": "9.1.36", - "integrity": "sha512-v1crfIUg8rUVmrhtSTDoZZNub9At2iMiDgR4BK+3SA1VmhO7swGwnff0OkSoteE60kdxN+70AmKJJWlX+11WTA==", - "resolved": "https://registry.simatic-ax.siemens.io/@ax/stc/-/stc-9.1.36.tgz", + "version": "11.1.55", + "integrity": "sha512-F24/kidxvVPkdFz1DCzk0kuLzhE21Hl/OZ53hedk4Ut+vkqtyWpk0zzqazMl+0cio8cayfW0kDGr/byyESUS2A==", + "resolved": "https://registry.simatic-ax.siemens.io/@ax/stc/-/stc-11.1.55.tgz", "dependencies": { - "@ax/stc-win-x64": "9.1.36", - "@ax/stc-linux-x64": "9.1.36" + "@ax/stc-linux-x64": "11.1.55", + "@ax/stc-win-x64": "11.1.55" } }, - "@ax/stc-win-x64": { - "name": "@ax/stc-win-x64", - "version": "9.1.36", - "integrity": "sha512-Ibmdf+eqfe4GzSxeZz3bxW3NStfscNDVtlmjI2enjpmSIybTak3xH4JHpQHJFkJEJqx9aMndue3GFKpPs16ovw==", - "resolved": "https://registry.simatic-ax.siemens.io/@ax/stc-win-x64/-/stc-win-x64-9.1.36.tgz", + "@ax/stc-linux-x64": { + "name": "@ax/stc-linux-x64", + "version": "11.1.55", + "integrity": "sha512-HacfsylKTabNefS95J3Iu0R4D/qm374OythdVgCnVdD21qy3kZMNZCWpfJkjwW4pao1CGlA7IxPTY4ip081/Hg==", + "resolved": "https://registry.simatic-ax.siemens.io/@ax/stc-linux-x64/-/stc-linux-x64-11.1.55.tgz", "os": [ - "win32" + "linux" ], "cpu": [ "x64" ], "dependencies": { - "@ax/st-docs": "9.1.36" + "@ax/st-docs": "11.1.55" } }, - "@ax/stc-linux-x64": { - "name": "@ax/stc-linux-x64", - "version": "9.1.36", - "integrity": "sha512-mlOpXtZ1V2VZNFRSb8PyqhQpPZ0a2Q3m0J/d0n/s4iIIEaneUON/JtywCTAQdvQJYer5PuKDoZf/dBLlgNRuRQ==", - "resolved": "https://registry.simatic-ax.siemens.io/@ax/stc-linux-x64/-/stc-linux-x64-9.1.36.tgz", + "@ax/stc-win-x64": { + "name": "@ax/stc-win-x64", + "version": "11.1.55", + "integrity": "sha512-Iqy5dWiHjz6ff3iwPhPtmr528r+F5sBiQm0CRZCGiiCMrr74GveNIlyQFdeXbVFWcgNwc8piHBXE84CbbXvftg==", + "resolved": "https://registry.simatic-ax.siemens.io/@ax/stc-win-x64/-/stc-win-x64-11.1.55.tgz", "os": [ - "linux" + "win32" ], "cpu": [ "x64" ], "dependencies": { - "@ax/st-docs": "9.1.36" + "@ax/st-docs": "11.1.55" } - }, - "@ax/st-docs": { - "name": "@ax/st-docs", - "version": "9.1.36", - "integrity": "sha512-xxUUXzm9VSf7p0yaOKZ+kep2+JDq9eqD2ddGNhysvocLI3SZhDxF693axQpCoJA2PxhpJdut+lXSZkCgNOVIsA==", - "resolved": "https://registry.simatic-ax.siemens.io/@ax/st-docs/-/st-docs-9.1.36.tgz", - "dependencies": {} } }, "workspaces": {} diff --git a/src/apax/apax.yml b/src/apax/apax.yml index 55ce3935c..1b796fadf 100644 --- a/src/apax/apax.yml +++ b/src/apax/apax.yml @@ -3,8 +3,7 @@ version: 0.0.0 type: app targets: - "1500" - - axunit-llvm devDependencies: - "@ax/stc": 9.1.36 + "@ax/stc": 11.1.55 installStrategy: strict apaxVersion: 3.1.1