public void TestMachineEntryDeclarationWithUnexpectedIdentifier()
{
var test = @"
namespace Foo {
machine M {
group G {
start state S
{
entry Bar {}
}
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \"{\".",
parser.GetParsingErrorLog());
}
public void TestMonitorOnEventDeclarationWithoutHandler()
{
var test = @"
namespace Foo {
monitor M {
group G {
start state S1
{
on e;
}
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \"do\", \"goto\" or \"push\".",
parser.GetParsingErrorLog());
}
public void TestMonitorIgnoreEventDeclarationWithExtraComma()
{
var test = @"
namespace Foo {
monitor M {
group G {
start state S
{
ignore e1,e2,;
}
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected event identifier.",
parser.GetParsingErrorLog());
}
public void TestMachineOnEventGotoStateDeclarationWithoutSemicolon()
{
var test = @"
namespace Foo {
machine M {
group G {
start state S1
{
on e goto S2
}
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \";\".",
parser.GetParsingErrorLog());
}
public void TestMonitorStateDeclarationWithMoreThanOneExit()
{
var test = @"
namespace Foo {
monitor M {
group G {
start state S
{
exit{}
exit {}
}
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Duplicate exit declaration.",
parser.GetParsingErrorLog());
}
internal static void AssertFailedTestLog(string expectedResult, string test)
{
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.Equal(expectedResult, parser.GetParsingErrorLog());
}
/// <summary>
/// Starts the P# parsing process.
/// </summary>
public void Start()
{
Output.WriteLine(". Parsing");
// Creates the P# parsing options.
ParsingOptions options = ParsingOptions.CreateDefault()
.EnableExitOnError().DisableThrowParsingException();
// Creates and runs a P# parsing engine.
ParsingEngine.Create(this.CompilationContext, options).Run();
}
public void TestNamespaceDeclarationWithoutIdentifier()
{
var test = "namespace { }";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected namespace identifier.",
parser.GetParsingErrorLog());
}
public void TestEventDeclarationWithoutNamespace()
{
var test = "event e;";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Must be declared inside a namespace.",
parser.GetParsingErrorLog());
}
public void TestIncorrectUsingDeclaration()
{
var test = "using System.Text";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \";\".",
parser.GetParsingErrorLog());
}
public void TestUnexpectedTokenWithoutNamespace()
{
var test = "private";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Unexpected token.",
parser.GetParsingErrorLog());
}
public void TestProtectedMonitorDeclaration()
{
var test = @"
namespace Foo {
protected monitor M { }
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.Equal("A monitor cannot be declared as protected.", parser.GetParsingErrorLog());
}
public void TestPrivateEventDeclaration()
{
var test = @"
namespace Foo {
private event e;
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual(parser.GetParsingErrorLog(),
"Event and machine declarations must be internal or public.");
}
public void TestEventDeclarationWithGenericError1()
{
var test = @"
namespace Foo {
event e>;
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \"(\" or \";\".",
parser.GetParsingErrorLog());
}
public void TestMachineDeclarationWithoutState()
{
var test = @"
namespace Foo {
machine M {
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("A machine must declare at least one state.",
parser.GetParsingErrorLog());
}
public void TestMonitorColdGroup()
{
var test = @"
namespace Foo {
monitor M {
cold group G { }
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("A state group cannot be cold.",
parser.GetParsingErrorLog());
}
public void TestMonitorGroupName()
{
var test = @"
namespace Foo {
monitor M {
group G.G2 { }
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \"{\".",
parser.GetParsingErrorLog());
}
public void TestInternalFieldDeclaration()
{
var test = @"
namespace Foo {
machine M {
internal int k;
start state S { }
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("A field or method cannot be internal.",
parser.GetParsingErrorLog());
}
public IEnumerable <SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories,
SnapshotSpan range, CancellationToken cancellationToken)
{
return(Enumerable.Empty <SuggestedActionSet>());
TextExtent extent;
if (!this.TryGetWordUnderCaret(out extent) || !extent.IsSignificant)
{
return(Enumerable.Empty <SuggestedActionSet>());
}
var extentToken = new PSharpLexer().Tokenize(extent.Span.GetText()).FirstOrDefault();
if (extentToken == null)
{
return(Enumerable.Empty <SuggestedActionSet>());
}
var snapshot = extent.Span.Snapshot;
var trackSpan = range.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive);
var preSpan = new SnapshotSpan(snapshot, new Span(snapshot.GetLineFromLineNumber(0).Start,
trackSpan.GetStartPoint(snapshot).Position));
var tokens = new PSharpLexer().Tokenize(preSpan.GetText());
var parser = new PSharpParser(ParsingOptions.CreateDefault());
parser.ParseTokens(tokens);
var expected = parser.GetExpectedTokenTypes();
if (this.IsExpectedTokenType(extentToken, expected))
{
return(Enumerable.Empty <SuggestedActionSet>());
}
var errorFixAction = new ErrorFixSuggestedAction(trackSpan);
return(new SuggestedActionSet[] { new SuggestedActionSet(new ISuggestedAction[] { errorFixAction }) });
}
public void TestQualifiedDefaultEvent()
{
var test = @"
namespace Foo {
machine M {
start state S
{
on Foo.default goto S2;
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected identifier.",
parser.GetParsingErrorLog());
}
public void TestIncorrectGenericEvent()
{
var test = @"
namespace Foo {
machine M {
start state S
{
on e<<int> goto S2;
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Unexpected token inside a generic name.",
parser.GetParsingErrorLog());
}
public void TestMachineMethodInsideGroup()
{
var test = @"
namespace Foo {
machine M {
group G {
void Bar() { }
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Unexpected token 'void'.",
parser.GetParsingErrorLog());
}
public void TestDeferEventDeclarationWithoutComma()
{
var test = @"
namespace Foo {
machine M {
start state S
{
defer e1 e2;
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected \",\".",
parser.GetParsingErrorLog());
}
public void TestOnEventDoActionDeclarationWithGenericError3()
{
var test = @"
namespace Foo {
machine M {
start state S1
{
on e<List<int>>> do Bar;
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Invalid generic expression.",
parser.GetParsingErrorLog());
}
public void TestOnEventDoActionDeclarationWithIncorrectWildcardUse()
{
var test = @"
namespace Foo {
machine M {
start state S1
{
on e.* do Bar
}
}
}";
ParsingOptions options = ParsingOptions.CreateDefault()
.DisableThrowParsingException();
var parser = new PSharpParser(new PSharpProject(),
SyntaxFactory.ParseSyntaxTree(test), options);
var tokens = new PSharpLexer().Tokenize(test);
var program = parser.ParseTokens(tokens);
Assert.AreEqual("Expected identifier.",
parser.GetParsingErrorLog());
}
void ICompletionSource.AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
return; // TODO short-circuited for now
var keywords = Keywords.Get();
var snapshot = this.Buffer.CurrentSnapshot;
var trackSpan = this.FindTokenSpanAtPosition(session.GetTriggerPoint(this.Buffer), session);
var preSpan = new SnapshotSpan(snapshot, new Span(snapshot.GetLineFromLineNumber(0).Start,
trackSpan.GetStartPoint(snapshot).Position));
var tokens = new PSharpLexer().Tokenize(preSpan.GetText());
var parser = new PSharpParser(ParsingOptions.CreateDefault());
parser.ParseTokens(tokens);
this.RefineAvailableKeywords(parser.GetExpectedTokenTypes(), keywords);
this.CompletionList = new List <Completion>();
foreach (var keyword in keywords)
{
this.CompletionList.Add(new Completion(keyword.Key, keyword.Key,
keyword.Value.Item1, null, null));
}
if (keywords.Count == 0)
{
return;
}
completionSets.Add(new CompletionSet(
"Tokens",
"Tokens",
trackSpan,
this.CompletionList,
null));
}
public Task <bool> HasSuggestedActionsAsync(ISuggestedActionCategorySet requestedActionCategories,
SnapshotSpan range, CancellationToken cancellationToken)
{
return(Task.Factory.StartNew(() =>
{
return false;
TextExtent extent;
if (!this.TryGetWordUnderCaret(out extent))
{
return false;
}
var extentToken = new PSharpLexer().Tokenize(extent.Span.GetText()).FirstOrDefault();
if (extentToken == null)
{
return false;
}
var snapshot = extent.Span.Snapshot;
var trackSpan = range.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive);
var preSpan = new SnapshotSpan(snapshot, new Span(snapshot.GetLineFromLineNumber(0).Start,
trackSpan.GetStartPoint(snapshot).Position));
var tokens = new PSharpLexer().Tokenize(preSpan.GetText());
var parser = new PSharpParser(ParsingOptions.CreateDefault());
parser.ParseTokens(tokens);
var expected = parser.GetExpectedTokenTypes();
if (this.IsExpectedTokenType(extentToken, expected))
{
return false;
}
return extent.IsSignificant;
}));
}
