sysml-v2-lsp 0.1.6 → 0.2.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "sysml-v2-lsp",
   "displayName": "SysML v2 Language Server",
   "description": "Language Server Protocol implementation for SysML v2, powered by ANTLR4",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "publisher": "JamieD",
   "license": "MIT",
   "repository": {
@@ -127,4 +127,4 @@
     "zod": "^4.3.6"
   },
   "dependencies": {}
-}
+}

package/sysml.library/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>sysml.library</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+	</natures>
+</projectDescription>

package/sysml.library/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

package/sysml.library/Domain Libraries/Analysis/.meta.json

@@ -0,0 +1,10 @@
+{
+  "index": {
+    "AnalysisTooling": "AnalysisTooling.sysml",
+    "SampledFunctions": "SampledFunctions.sysml",
+    "StateSpaceRepresentation": "StateSpaceRepresentation.sysml",
+    "TradeStudies": "TradeStudies.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

package/sysml.library/Domain Libraries/Analysis/.project.json

@@ -0,0 +1,27 @@
+{
+  "name": "SysML Analysis Library",
+  "version": "2.0.0",
+  "description": "Standard analysis domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Quantities-and-Units-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
+}

package/sysml.library/Domain Libraries/Analysis/AnalysisTooling.sysml

@@ -0,0 +1,34 @@
+standard library package AnalysisTooling {
+	doc
+	/*
+	 * This package contains definitions for metadata annotations related
+	 * to analysis tool integration.
+	 */
+
+	private import ScalarValues::*;
+	
+	metadata def ToolExecution {
+		doc
+		/*
+		 * ToolExecution metadata identifies an external analysis tool to be
+		 * used to implement the annotated action.
+		 */
+	
+		attribute toolName : String;
+		attribute uri : String;
+	}
+	
+	metadata def ToolVariable {
+		doc
+		/*
+		 * ToolVariable metadata is used in the context of an action that has
+		 * been annotated with ToolExecution metadata. It is used to annotate
+		 * a parameter or other feature of the action with the name of the
+		 * variable in the tool that is to correspond to the annotated
+		 * feature.
+		 */
+	
+		attribute name : String;
+	}
+	
+}

package/sysml.library/Domain Libraries/Analysis/SampledFunctions.sysml

@@ -0,0 +1,119 @@
+standard library package SampledFunctions {
+	doc
+	/*
+	 * This package provides a library model of discretely sampled mathematical functions.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::Positive;
+	private import Collections::KeyValuePair;
+	private import Collections::OrderedMap;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::forAll;
+	private import ControlFunctions::collect;
+	private import ControlFunctions::select;
+	
+    attribute def SamplePair :> KeyValuePair {
+		doc
+		/*
+		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
+		 */
+	
+        attribute domainValue :>> key;
+        attribute rangeValue :>> val;
+    }
+
+	attribute def SampledFunction :> OrderedMap {
+		doc
+		/*
+	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, 
+	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
+	     * decreasing.
+	     * 
+	     * It maps discrete domain values to discrete range values.
+	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and 
+	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
+	     */
+	
+		attribute samples: SamplePair[0..*] ordered :>> elements;
+		
+		assert constraint {
+			// Note: Assumes the functions '<' and '>' are defined for the domain type.
+			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing
+            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing
+		}
+	}
+	
+	calc def Domain { 
+		doc
+		/* 
+		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.
+		 */
+		 
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.domainValue;
+	}
+	
+	calc def Range { 
+		doc
+		/* 
+		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.
+		 */
+			
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.rangeValue;
+	}
+	
+	calc def Sample {
+		doc
+		/* 
+		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
+		 */
+		 
+		in calc calculation { in x; }
+		in attribute domainValues [0..*];
+		return sampling = new SampledFunction (
+			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }
+		);
+	}
+	
+	calc def Interpolate {
+		doc
+		/*
+		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
+		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		return attribute result;
+	}
+		
+	calc interpolateLinear : Interpolate {
+		doc
+		/*
+		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		
+		private attribute domainValues = Domain(fn);
+		private attribute index : Positive[0..1] =
+			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
+			
+		private calc def Linear {
+			in attribute lowerSample : SamplePair;
+			in attribute upperSample : SamplePair;
+			in attribute value;
+			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
+			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				
+		}
+		
+		return result [0..1] =
+			if index == null or index == size(domainValues)? null
+			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
+			else Linear(fn.samples#(index+1), fn.samples#(index), value);
+	}
+	
+}

package/sysml.library/Domain Libraries/Analysis/StateSpaceRepresentation.sysml

@@ -0,0 +1,143 @@
+standard library package StateSpaceRepresentation {
+	doc
+	/*
+	 * This package provides a model of the foundational state-space system representation, 
+	 * commonly used in control systems.
+	 */
+
+    private import ISQ::DurationValue;
+    private import Quantities::VectorQuantityValue;
+    private import VectorCalculations::*;
+
+    abstract attribute def StateSpace :> VectorQuantityValue;
+    abstract attribute def Input :> VectorQuantityValue;
+    abstract attribute def Output :> VectorQuantityValue;
+
+    abstract calc def GetNextState { 
+    	in input: Input; 
+    	in stateSpace: StateSpace; 
+    	in timeStep: DurationValue; 
+    	return : StateSpace;
+    }
+    abstract calc def GetOutput {
+    	in input: Input; 
+    	in stateSpace: StateSpace;
+    	return : Output;
+	}
+	
+     abstract action def StateSpaceEventDef {
+    	doc
+    	/*
+    	 * Events to be received.
+    	 */
+    }
+    action def ZeroCrossingEventDef :> StateSpaceEventDef;
+
+    item def StateSpaceItem {
+    	doc
+    	/*
+    	 * Item for SSR connection
+    	 */
+    }
+
+    abstract action def StateSpaceDynamics {
+	    doc
+	    /*
+	     * StateSpaceDynamics is the simplest form of State Space Representation,
+	     * and nextState directly computes the stateSpace of the next timestep. 
+	     */
+    
+        in attribute input: Input;
+
+        abstract calc getNextState: GetNextState;
+        abstract calc getOutput: GetOutput;
+        attribute stateSpace: StateSpace;
+
+        out attribute output: Output = getOutput(input, stateSpace);
+    }
+
+    abstract attribute def StateDerivative :> VectorQuantityValue {
+	    doc
+	    /*
+	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
+	     */
+    
+        ref stateSpace: StateSpace;
+        constraint { stateSpace.order == order }
+    }
+
+    abstract calc def GetDerivative {
+	    doc
+	    /*
+	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
+	     */
+	    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateDerivative;
+	}
+	
+    abstract calc def Integrate {
+	    doc
+	    /*
+	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
+	     * Its actual implementation should be given by a solver. 
+	     */
+    
+        in getDerivative: GetDerivative;
+        in input: Input;
+        in initialState: StateSpace;
+        in timeInterval: DurationValue;
+        return result: StateSpace;
+	}
+	
+    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * ContinuousStateSpaceDynamics represents continuous behavior.
+	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
+	     */
+    
+        abstract calc getDerivative: GetDerivative;
+        calc :>> getNextState: GetNextState {
+            /* We compute nextState by Integrate defined above by giving derivative calc. */
+            calc integrate: Integrate {
+                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
+                in input = GetNextState::input;
+                in initialState = GetNextState::stateSpace;
+                in timeInterval = GetNextState::timeStep;
+           }
+           return result = integrate.result;
+        }
+
+        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
+        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ 
+        }
+    }
+
+    abstract calc def GetDifference {
+    	doc
+	    /*
+	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
+	     * where k is the timestep number. 
+	     */
+    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateSpace;
+	}
+	
+    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * DiscreteStateSpaceDynamics represents discrete behavior.
+	     * differences needs to return difference of the stateSpace for each timestep.
+	     */
+    
+        abstract calc getDifference: GetDifference;
+        calc :>> getNextState: GetNextState {
+            attribute diff: StateSpace = getDifference(input, stateSpace);
+            return result = stateSpace + diff;
+        }
+    }
+}

package/sysml.library/Domain Libraries/Analysis/TradeStudies.sysml

@@ -0,0 +1,171 @@
+standard library package TradeStudies {
+	doc
+	/*
+	 * This package provides a simple framework for defining trade-off study analysis cases.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import ScalarFunctions::*;
+	private import ControlFunctions::*;
+	
+	abstract calc def EvaluationFunction {
+		doc
+		/*
+		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,
+		 * producing a ScalarValue that can be comparted with the evaluation of other
+		 * alternatives.
+		 */
+	
+		in ref alternative : Anything {
+			doc
+			/*
+			 * The alternative to be evaluated.
+			 */
+		} 
+		
+		return attribute result : ScalarValue[1] {
+			doc
+			/*
+			 * A ScalarValue representing the evaluation of the given alternative.
+			 */
+		} 
+	}
+	
+	abstract requirement def TradeStudyObjective {
+		doc
+		/*
+		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.
+		 * The requirement is to choose from a given set of alternatives the selectedAlternative
+		 * for that has the best evaluation according to a given EvaluationFunction. What
+		 * value is considered "best" is not defined in the abstract base definition but must be
+		 * computed in any concrete specialization.
+		 */
+	
+		subject selectedAlternative : Anything {
+			doc
+			/*
+			 * The alternative that should be selected, as evaluated using the given 
+			 * ObjectiveFunction.
+			 */
+		}
+		
+		in ref alternatives : Anything[1..*] {
+			doc
+			/*
+			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective 
+			 * is the objective.
+			 */
+		}
+		
+		in calc eval : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used in evaluating the given alternatives.
+			 */
+		}
+		
+		attribute best : ScalarValue {
+			doc
+			/*
+			 * Out of the evaluation results of all the given alternatives, the one that is considered 
+			 * "best", in the sense that it is the value the selectedAlternative should have. This 
+			 * value must be computed in any concrete specialization of TradeStudyObjective.
+			 */
+		}
+				
+		require constraint { eval(selectedAlternative) == best }
+	}
+	
+	requirement def MinimizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MinimizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the minimum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+		 
+		attribute :>> best = alternatives->minimize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the minimum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	requirement def MaximizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MaximizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the maximum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+	
+		attribute :>> best = alternatives->maximize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the maximum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	abstract analysis def TradeStudy {
+		doc
+		/*
+		 * A TradeStudy is an analysis case whose subject is a set of alternatives
+		 * (at least one) and whose result is a selection of one of those alternatives.
+		 * The alternatives are evaluated based on a given ObjectiveFunction and the
+		 * selection is made such that it satisfies the objective of the TradeStudy
+		 * (which must be a TradeStudyObjective).
+		 */
+	
+		subject studyAlternatives : Anything[1..*] {
+			doc
+			/*
+			 * The set of alternatives being considered in this TradeStudy. 
+			 * 
+			 * In a TradeStudy usage, bind this feature to the actual collection of
+			 * alternatives to be considered.
+			 */
+		}
+		
+		abstract calc evaluationFunction : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used to evaluate the alternatives.
+			 * 
+			 * In a TradeStudy usage, redefine this feature to provide the desired
+			 * calculation (or bind it to a calculation usage that does so).
+			 */
+		}
+		
+		objective tradeStudyObjective : TradeStudyObjective {
+			doc
+			/*
+			 * The objective of this TradeStudy.
+			 * 
+			 * Redefine this feature to give it a definition that is a concrete
+			 * specialization of TradeStudyObjective. That can either be one of the
+			 * specializations provided in this package, or a more specific user-
+			 * defined one.
+			 */
+		
+            subject :>> selectedAlternative;
+			in ref :>> alternatives = studyAlternatives;
+			in calc :>> eval = evaluationFunction;
+		}
+		
+		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {
+			doc
+			/*
+			 * The alternative selected by this TradeStudy, which is the one that meets the
+			 * requirement of the tradeStudyObjective.
+			 */
+		} tradeStudyObjective(selectedAlternative = a)};
+	}
+	
+}

package/sysml.library/Domain Libraries/Cause and Effect/.meta.json

@@ -0,0 +1,8 @@
+{
+  "index": {
+    "CausationConnections": "CausationConnections.sysml",
+    "CauseAndEffect": "CauseAndEffect.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

package/sysml.library/Domain Libraries/Cause and Effect/.project.json

@@ -0,0 +1,23 @@
+{
+  "name": "SysML Cause and Effect Library",
+  "version": "2.0.0",
+  "description": "Standard cause-and-effect domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
+}

package/sysml.library/Domain Libraries/Cause and Effect/CausationConnections.sysml

@@ -0,0 +1,83 @@
+standard library package CausationConnections {	
+	doc 
+	/* 
+	 * This package provides a library model modeling causes, effects, and causation connections 
+	 * between them.
+	 */
+
+	private import SequenceFunctions::isEmpty;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::intersection;
+		 
+	abstract occurrence causes[*] {
+		doc /* Occurrences that are causes. */
+	}
+	
+	abstract occurrence effects[*]  {
+		doc /* Occurrences that are effects. */
+	}
+	
+	abstract connection def Multicausation {
+		doc
+		/*
+		 * A Multicausation connection models the situation in which one set of
+		 * occurrences causes another.
+		 * 
+		 * To create a Multicausation connection, specialize this connection definition
+		 * adding specific end features of the relavent types. Ends representing causes
+		 * should subset 'causes', while ends representing effects should subset 'effects'.
+		 * There must be at least one cause and at least one effect.
+		 */
+		 
+		abstract constant ref occurrence causes[1..*] :>> causes :> participant {
+			doc 
+			/* 
+			 * The causing occurrences. (Constant for each Multicausation instance.)
+			 */
+		}
+		abstract constant ref occurrence effects[1..*] :>> effects :> participant {
+			doc 
+			/* 
+			 * The effect occurrences caused by the causing occurrences. 
+			 * (Constant for each Multicausation instance.)
+			 */
+		}
+		
+		private assert constraint disjointCauseEffect {
+			doc /* causes must be disjoint from effects. */
+			isEmpty(intersection(causes, effects))
+		}
+		
+		private succession causalOrdering first [nCauses] causes.startShot then [nEffects] effects {
+			doc /* All causes must exist before all effects. */
+			attribute nCauses = size(causes);
+			attribute nEffects = size(effects);
+		}
+	}
+	
+	abstract connection multicausations : Multicausation[*] {
+		doc /* multicausations is the base feature for Multicausation ConnectionUsages. */
+	}
+	
+	connection def Causation :> Multicausation {
+		doc
+		/*
+		 * A Causation is a binary Multicausation in which a single cause occurrence
+		 * causes a single effect occurrence. (However, a single cause can separately
+		 * have multiple effects, and a single effect can have separate Causation
+		 * connections with multiple causes.)
+		 */
+		
+		end theCauses [*] occurrence theCause :> causes :>> source {
+		    doc /* The single causing occurrence. */
+		}
+		
+		end theEffects [*] occurrence theEffect :> effects :>> target {
+			doc /* The single effect occurrence resulting from the cause. */
+		}
+	}
+	
+	abstract connection causations : Causation[*] :> multicausations {
+		doc /* causations is the base feature for Causation ConnectionUsages. */
+	}
+}