public BVE5Resolver(BVE5Compilation compilation, SimpleTypeResolveContext context, Dictionary<string, ResolveResult> nameLookupCache, ImmutableStack<IVariable> stack)
{
this.compilation = compilation;
this.context = context;
user_defined_name_lookup_cache = nameLookupCache;
local_variable_stack = stack;
}
private State GetOrCreateStateForLabel(string labelName, ImmutableStack<Tuple<int, string>> finallyStack) {
State result;
if (_labelStates.TryGetValue(labelName, out result))
return result;
_labelStates[labelName] = result = CreateNewStateValue(finallyStack);
return result;
}
public RemainingBlock(ImmutableStack<StackEntry> stack, ImmutableStack<Tuple<string, State>> breakStack, ImmutableStack<Tuple<string, State>> continueStack, State stateValue, State returnState) {
Stack = stack;
BreakStack = breakStack;
ContinueStack = continueStack;
StateValue = stateValue;
ReturnState = returnState;
}
private State CreateNewStateValue(ImmutableStack<Tuple<int, string>> finallyStack, string finallyHandlerToPush = null) {
int value = _nextStateIndex++;
finallyStack = finallyHandlerToPush != null ? finallyStack.Push(Tuple.Create(value, finallyHandlerToPush)) : finallyStack;
var result = new State(_currentLoopLabel, value, finallyStack);
_allStates.Add(result);
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="ActivationRecord"/> class.
/// </summary>
/// <param name="type">
/// The routine type.
/// </param>
/// <param name="programCounter">
/// The program counter.
/// </param>
/// <param name="argumentCount">
/// The argument count.
/// </param>
/// <param name="localVariables">
/// The local variables.
/// </param>
/// <param name="evaluationStack">
/// The evaluation stack.
/// </param>
public ActivationRecord(RoutineType type, int programCounter, byte argumentCount, ImmutableArray<int> localVariables, ImmutableStack<int> evaluationStack)
{
this.argumentCount = argumentCount;
this.type = type;
this.localVariables = localVariables;
this.programCounter = programCounter;
this.evaluationStack = evaluationStack;
}
public static IMarkdownContext SetFilePathStack(this IMarkdownContext context, ImmutableStack<string> filePathStack)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return context.CreateContext(context.Variables.SetItem(FilePathStackKey, filePathStack));
}
public Turtle(Vector pos, double angle, ImmutableStack<TurtleState> stack, Action<int, int, int, int, Color> drawLine, Color c)
{
this.Position = pos;
this.Angle = angle;
this.Stack = stack;
this.DrawLine = drawLine;
this.DrawColor = c;
}
public void Dispose()
{
foreach (var item in _disposables)
{
item.Dispose();
}
_disposables = ImmutableStack<IDisposable>.Empty;
}
public void Add(IDisposable disposable)
{
if (disposable == null)
{
throw Logger.Fatal.ArgumentNull(nameof(disposable));
}
_disposables = _disposables.Push(disposable);
}
public void Add(Action action)
{
if (action == null)
{
throw Logger.Fatal.ArgumentNull(nameof(action));
}
_disposables = _disposables.Push(new HarshDisposableAction(action));
}
public static void Start(ActivityScope scope)
{
var parent = ActivityStack.Any() ? ActivityStack.Peek() : null;
if (parent != null)
scope.ParentId = parent.Id;
ActivityStack = ActivityStack.Push(scope);
}
private void Enqueue(ImmutableStack<StackEntry> stack, ImmutableStack<Tuple<string, State>> breakStack, ImmutableStack<Tuple<string, State>> continueStack, State stateValue, State returnState)
{
if (_processedStates.Contains(stateValue))
throw new InvalidOperationException("Duplicate enqueueing of " + stateValue);
_processedStates.Add(stateValue);
if (stack.IsEmpty)
throw new InvalidOperationException("Empty stack for state " + stateValue);
_remainingBlocks.Enqueue(new RemainingBlock(stack, breakStack, continueStack, stateValue, returnState));
}
public Reader(Blender blender)
{
this.lexer = blender.lexer;
this.oldTreeCursor = blender.oldTreeCursor;
this.changes = blender.changes;
this.newPosition = blender.newPosition;
this.changeDelta = blender.changeDelta;
this.newDirectives = blender.newDirectives;
this.oldDirectives = blender.oldDirectives;
this.newLexerDrivenMode = blender.newLexerDrivenMode;
}
internal string InternalMarkup(string src, ImmutableStack<string> parents, HashSet<string> dependency)
{
using (GetFileScope(parents))
{
return InternalMarkup(
src,
Context
.SetFilePathStack(parents)
.SetDependency(dependency));
}
}
private CppResolver(ICompilation compilation, Conversions conversions, CppTypeResolveContext context, bool checkForOverflow, bool isWithinLambdaExpression, TypeDefinitionCache currentTypeDefinitionCache, ImmutableStack<IVariable> localVariableStack, ObjectInitializerContext objectInitializerStack)
{
this.compilation = compilation;
this.conversions = conversions;
this.context = context;
this.checkForOverflow = checkForOverflow;
this.isWithinLambdaExpression = isWithinLambdaExpression;
this.currentTypeDefinitionCache = currentTypeDefinitionCache;
this.localVariableStack = localVariableStack;
this.objectInitializerStack = objectInitializerStack;
}
public Reader(Blender blender)
{
_lexer = blender._lexer;
_oldTreeCursor = blender._oldTreeCursor;
_changes = blender._changes;
_newPosition = blender._newPosition;
_changeDelta = blender._changeDelta;
_newDirectives = blender._newDirectives;
_oldDirectives = blender._oldDirectives;
_newLexerDrivenMode = blender._newLexerDrivenMode;
}
public static PositionedUnit PositionNewUnit(int width, ImmutableStack<Unit> nextUnits)
{
if (nextUnits.IsEmpty) return PositionedUnit.Null;
var u = nextUnits.Peek();
var topmostY = u.Displacements[0].Min(m => m.ToMap().Y);
var pos = new PositionedUnit(u, 0, new Point(0, -topmostY));
var leftMargin = pos.Members.Min(m => m.X);
var rightMargin = width - 1 - pos.Members.Max(m => m.X);
var newX = (rightMargin - leftMargin) / 2;
return new PositionedUnit(u, 0, new Point(newX, -topmostY));
}
public Map(int id, bool[,] filled, PositionedUnit unit, ImmutableStack<Unit> nextUnits, ImmutableHashSet<PositionedUnit> usedPositions, Scores scores, bool died = false)
{
Id = id;
NextUnits = nextUnits;
Width = filled.GetLength(0);
Height = filled.GetLength(1);
Filled = filled;
Unit = IsValidPosition(unit) ? unit : PositionedUnit.Null;
UsedPositions = usedPositions.Add(Unit);
Scores = scores;
Died = died;
}
private static LoggerFileScope GetFileScope(ImmutableStack<string> parents)
{
if (!parents.IsEmpty)
{
var path = StringExtension.ToDisplayPath(parents.Peek());
if (!string.IsNullOrEmpty(path))
{
return new LoggerFileScope(path);
}
}
return null;
}
public static void End(ActivityScope scope)
{
if (Current == null)
return;
if (ActivityStack.All(scopeOnTheStack => scope.Id != scopeOnTheStack.Id))
return;
ActivityScope currentScope;
ActivityStack = ActivityStack.Pop(out currentScope);
while(ActivityStack.Any() && currentScope.Id != scope.Id) {
ActivityStack = ActivityStack.Pop(out currentScope);
}
}
public Blender(Lexer lexer, CSharp.CSharpSyntaxNode oldTree, IEnumerable<TextChangeRange> changes)
{
Debug.Assert(lexer != null);
_lexer = lexer;
_changes = ImmutableStack.Create<TextChangeRange>();
if (changes != null)
{
// TODO: Consider implementing NormalizedChangeCollection for TextSpan. the real
// reason why we are collapsing is because we want to extend change ranges and
// cannot allow them to overlap. This does not seem to be a big deal since multiple
// changes are infrequent and typically close to each other. However if we have
// NormalizedChangeCollection for TextSpan we can have both - we can extend ranges
// and not require collapsing them. NormalizedChangeCollection would also ensure
// that changes are always normalized.
// TODO: this is a temporary measure to prevent individual change spans from
// overlapping after they are widened to effective width (+1 token at the start).
// once we have normalized collection for TextSpan we will not need to collapse all
// the change spans.
var collapsed = TextChangeRange.Collapse(changes);
// extend the change to its affected range. This will make it easier
// to filter out affected nodes since we will be able simply check
// if node intersects with a change.
var affectedRange = ExtendToAffectedRange(oldTree, collapsed);
_changes = _changes.Push(affectedRange);
}
if (oldTree == null)
{
// start at lexer current position if no nodes specified
_oldTreeCursor = new Cursor();
_newPosition = lexer.TextWindow.Position;
}
else
{
_oldTreeCursor = Cursor.FromRoot(oldTree).MoveToFirstChild();
_newPosition = 0;
}
_changeDelta = 0;
_newDirectives = default(DirectiveStack);
_oldDirectives = default(DirectiveStack);
_newLexerDrivenMode = 0;
}
RecEnumerateOutcomes(
ImmutableStack<Func<DiscriminatedUnionCaseParameter, DestructureMethodParameter>> results,
Func<DiscriminatedUnionCaseParameter, DestructureMethodParameter>[] resultTypes,
int numIterations)
{
if (results.Count() >= numIterations)
{
yield return results;
}
else
{
foreach (var resultType in resultTypes)
{
foreach (var a in RecEnumerateOutcomes(results.Push(resultType), resultTypes, numIterations))
{
yield return a;
}
}
}
}
/// <summary>
/// Appends an abbreviation to the given zscii text.
/// </summary>
/// <param name="zcharacter">
/// The zcharacter.
/// </param>
/// <param name="calledRecursively">
/// A value which indicates whether the method was called recursively.
/// </param>
/// <param name="zcharacters">
/// The zcharacters.
/// </param>
/// <param name="zsciiText">
/// The zscii text.
/// </param>
protected void AppendAbbreviation(byte zcharacter, bool calledRecursively, ref ImmutableStack<byte> zcharacters, ref ImmutableStack<Zscii> zsciiText)
{
if (calledRecursively)
{
this.FrontEnd.ErrorNotification(ErrorCondition.NestedAbbreviation, "Nested abbreviation detected.");
return;
}
if (zcharacters != null)
{
var abbreviationNumber = ((zcharacter - 1) * 32) + zcharacters.Top;
zcharacters = zcharacters.Tail;
var abbreviationsTableAddress = this.Memory.ReadWord(24);
var abbreviationAddress = 2 * this.Memory.ReadWord(abbreviationsTableAddress + (2 * abbreviationNumber));
var abbreviation = this.ZCharactersToZscii(true, this.EncodedTextToZCharacters(ref abbreviationAddress));
foreach (var zsciiCharacter in abbreviation.Enumerable())
{
zsciiText = zsciiText.Add(zsciiCharacter);
}
}
}
private Blender(
Lexer lexer,
Cursor oldTreeCursor,
ImmutableStack<TextChangeRange> changes,
int newPosition,
int changeDelta,
DirectiveStack newDirectives,
DirectiveStack oldDirectives,
LexerMode newLexerDrivenMode)
{
Debug.Assert(lexer != null);
Debug.Assert(changes != null);
Debug.Assert(newPosition >= 0);
_lexer = lexer;
_oldTreeCursor = oldTreeCursor;
_changes = changes;
_newPosition = newPosition;
_changeDelta = changeDelta;
_newDirectives = newDirectives;
_oldDirectives = oldDirectives;
_newLexerDrivenMode = newLexerDrivenMode & (LexerMode.MaskXmlDocCommentLocation | LexerMode.MaskXmlDocCommentStyle);
}
public string InternalMarkup(string src, ImmutableStack <string> parents)
{
DfmEngine engine = new DfmEngine(Context, Rewriter, Renderer, Options);
return(Mark(Normalize(src), Context.SetFilePathStack(parents)).ToString());
}
public static T PeekOrDefault <T>(this ImmutableStack <T> stack)
{
return(stack.IsEmpty ? default(T) : stack.Peek());
}
public void Add(OpenTagStack openTags, ImmutableStack <InternalObject> document, uint cost)
{
Add(new Configuration(openTags, document, cost));
}
public Configuration(OpenTagStack openTags, ImmutableStack <InternalObject> document, uint cost)
{
this.OpenTags = openTags;
this.Document = document;
this.Cost = cost;
}
/// <summary>
/// Pushes an input handler onto the list of stacked input handlers.
/// </summary>
/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
public void PushStackedInputHandler(TextAreaStackedInputHandler inputHandler)
{
if (inputHandler == null)
throw new ArgumentNullException("inputHandler");
stackedInputHandlers = stackedInputHandlers.Push(inputHandler);
inputHandler.Attach();
}
List <InternalObject> CreateElements(ref ImmutableStack <InternalObject> inputObjects)
{
List <InternalObject> objects = new List <InternalObject>();
while (!inputObjects.IsEmpty)
{
var obj = inputObjects.Peek();
var tag = obj as InternalTag;
if (tag != null && tag.IsStartTag)
{
break;
}
inputObjects = inputObjects.Pop();
if (tag != null && tag.IsEndTag)
{
if (inputObjects.Peek() == StartTagPlaceholder)
{
objects.Add(tag.AddSyntaxError("Matching opening tag was not found"));
inputObjects = inputObjects.Pop();
}
else
{
var childElements = CreateElements(ref inputObjects);
var startTag = (InternalTag)inputObjects.Peek();
inputObjects = inputObjects.Pop();
childElements.Add(startTag);
childElements.Reverse();
if (tag != EndTagPlaceholder)
{
// add end tag
if (startTag.Name != tag.Name)
{
childElements.Add(tag.AddSyntaxError("Expected '</" + startTag.Name + ">'. End tag must have same name as start tag."));
}
else
{
childElements.Add(tag);
}
}
InternalElement e = new InternalElement(startTag);
e.HasEndTag = (tag != EndTagPlaceholder);
e.NestedObjects = new InternalObject[childElements.Count];
int pos = 0;
for (int i = 0; i < childElements.Count; i++)
{
e.NestedObjects[i] = childElements[i].SetStartRelativeToParent(pos);
pos += e.NestedObjects[i].Length;
}
e.Length = pos;
if (tag == EndTagPlaceholder)
{
e.SyntaxErrors = new [] { new InternalSyntaxError(pos, pos, "Missing '</" + startTag.Name + ">'") };
}
objects.Add(e);
}
}
else
{
objects.Add(obj);
}
}
return(objects);
}
internal static ThrownExceptionInfo CreateDefaultInfoForExceptionsPathAnalysis(BasicBlock block, WellKnownTypeProvider wellKnownTypeProvider, ImmutableStack <IOperation>?interproceduralCallStackOpt)
{
var exceptionNamedType = wellKnownTypeProvider.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemException);
RoslynDebug.Assert(exceptionNamedType != null);
return(new ThrownExceptionInfo(block, exceptionNamedType, interproceduralCallStackOpt, isDefaultExceptionForExceptionsPathAnalysis: true));
}
/// <summary>
/// Closes the current scope for local variables; removing all variables in that scope.
/// </summary>
public void PopBlock()
{
IVariable removedVar;
do {
removedVar = localVariableStack.Peek();
localVariableStack = localVariableStack.Pop();
} while (removedVar != null);
}
protected override IImmutableStack <T> Complete(T[] intermediateCollection)
{
return(ImmutableStack.CreateRange(intermediateCollection));
}
public ExtractMemberAccessVisitor()
{
Members = ImmutableStack.Create <MemberInfo>();
}
public static CompositionConfiguration Create(ComposableCatalog catalog)
{
Requires.NotNull(catalog, nameof(catalog));
// We consider all the parts in the catalog, plus the specially synthesized ones
// that should always be applied.
var customizedCatalog = catalog.AddParts(AlwaysBundledParts);
// Construct our part builders, initialized with all their imports satisfied.
// We explicitly use reference equality because ComposablePartDefinition.Equals is too slow, and unnecessary for this.
var partBuilders = new Dictionary <ComposablePartDefinition, PartBuilder>(ReferenceEquality <ComposablePartDefinition> .Default);
foreach (ComposablePartDefinition partDefinition in customizedCatalog.Parts)
{
var satisfyingImports = partDefinition.Imports.ToImmutableDictionary(i => i, i => customizedCatalog.GetExports(i.ImportDefinition));
partBuilders.Add(partDefinition, new PartBuilder(partDefinition, satisfyingImports));
}
// Create a lookup table that gets all immediate importers for each part.
foreach (PartBuilder partBuilder in partBuilders.Values)
{
// We want to understand who imports each part so we can properly propagate sharing boundaries
// for MEFv1 attributed parts. ExportFactory's that create sharing boundaries are an exception
// because if a part has a factory that creates new sharing boundaries, the requirement for
// that sharing boundary of the child scope shouldn't be interpreted as a requirement for that
// same boundary by the parent part.
// However, if the ExportFactory does not create sharing boundaries, it does in fact need all
// the same sharing boundaries as the parts it constructs.
var importedPartsExcludingFactoriesWithSharingBoundaries =
(from entry in partBuilder.SatisfyingExports
where !entry.Key.IsExportFactory || entry.Key.ImportDefinition.ExportFactorySharingBoundaries.Count == 0
from export in entry.Value
select export.PartDefinition).Distinct(ReferenceEquality <ComposablePartDefinition> .Default);
foreach (var importedPartDefinition in importedPartsExcludingFactoriesWithSharingBoundaries)
{
var importedPartBuilder = partBuilders[importedPartDefinition];
importedPartBuilder.ReportImportingPart(partBuilder);
}
}
// Propagate sharing boundaries defined on parts to all importers (transitive closure).
foreach (PartBuilder partBuilder in partBuilders.Values)
{
partBuilder.ApplySharingBoundary();
}
var sharingBoundaryOverrides = ComputeInferredSharingBoundaries(partBuilders.Values);
// Build up our set of composed parts.
var partsBuilder = ImmutableHashSet.CreateBuilder <ComposedPart>();
foreach (var partBuilder in partBuilders.Values)
{
var composedPart = new ComposedPart(partBuilder.PartDefinition, partBuilder.SatisfyingExports, partBuilder.RequiredSharingBoundaries.ToImmutableHashSet());
partsBuilder.Add(composedPart);
}
var parts = partsBuilder.ToImmutable();
// Determine which metadata views to use for each applicable import.
var metadataViewsAndProviders = GetMetadataViewProvidersMap(customizedCatalog);
// Validate configuration.
var errors = new List <ComposedPartDiagnostic>();
foreach (var part in parts)
{
errors.AddRange(part.Validate(metadataViewsAndProviders));
}
// Detect loops of all non-shared parts.
errors.AddRange(FindLoops(parts));
if (errors.Count > 0)
{
var invalidParts = ImmutableHashSet.CreateRange(errors.SelectMany(error => error.Parts).Select(p => p.Definition));
if (invalidParts.IsEmpty)
{
// If we can't identify the faulty parts but we still have errors, we have to just throw.
throw new CompositionFailedException(Strings.FailStableComposition, ImmutableStack.Create <IReadOnlyCollection <ComposedPartDiagnostic> >(errors));
}
var salvagedParts = catalog.Parts.Except(invalidParts);
var salvagedCatalog = ComposableCatalog.Create(catalog.Resolver).AddParts(salvagedParts);
var configuration = Create(salvagedCatalog);
return(configuration.WithErrors(errors));
}
return(new CompositionConfiguration(
catalog,
parts,
metadataViewsAndProviders,
ImmutableStack <IReadOnlyCollection <ComposedPartDiagnostic> > .Empty,
sharingBoundaryOverrides));
}
internal static AbstractLocation CreateAllocationLocation(IOperation creation, ITypeSymbol locationType, ImmutableStack <IOperation> callStackOpt) => Create(creation, callStackOpt, analysisEntityOpt: null, symbolOpt: null, captureIdOpt: null, locationType: locationType);
public MemberMetadataInfo()
{
Kind = MemberKind.Type;
Names = new List <string>();
Modifiers = ImmutableStack.Create <MemberModifiedMetadata>();
}
private Map(int id, bool[,] filled, PositionedUnit unit, ImmutableStack<Unit> nextUnits, Scores scores)
: this(id, filled,
unit,
nextUnits, ImmutableHashSet<PositionedUnit>.Empty.Add(unit), scores)
{
}
public static IMarkdownContext SetFilePathStack(this IMarkdownContext context, ImmutableStack <string> filePathStack)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.CreateContext(context.Variables.SetItem(FilePathStackKey, filePathStack)));
}
public static AbstractLocation CreateFlowCaptureLocation(InterproceduralCaptureId captureId, ITypeSymbol locationType, ImmutableStack <IOperation> creationCallStackOpt) => Create(creationOpt: null, creationCallStackOpt: creationCallStackOpt, analysisEntityOpt: null, symbolOpt: null, captureIdOpt: captureId, locationType: locationType);
public static AbstractLocation CreateThisOrMeLocation(INamedTypeSymbol namedTypeSymbol, ImmutableStack <IOperation> creationCallStackOpt) => Create(creationOpt: null, creationCallStackOpt: creationCallStackOpt, analysisEntityOpt: null, symbolOpt: namedTypeSymbol, captureIdOpt: null, locationType: namedTypeSymbol);
public void Initialize()
{
MyInt16 = 1;
MyInt32 = 2;
MyInt64 = 3;
MyUInt16 = 4;
MyUInt32 = 5;
MyUInt64 = 6;
MyByte = 7;
MySByte = 8;
MyChar = 'a';
MyString = "Hello";
MyBooleanTrue = true;
MyBooleanFalse = false;
MySingle = 1.1f;
MyDouble = 2.2d;
MyDecimal = 3.3m;
MyDateTime = new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc);
MyDateTimeOffset = new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0));
MyGuid = new Guid("1B33498A-7B7D-4DDA-9C13-F6AA4AB449A6");
MyUri = new Uri("https://github.com/dotnet/corefx");
MyEnum = SampleEnum.Two;
MyInt16Array = new short[] { 1 };
MyInt32Array = new int[] { 2 };
MyInt64Array = new long[] { 3 };
MyUInt16Array = new ushort[] { 4 };
MyUInt32Array = new uint[] { 5 };
MyUInt64Array = new ulong[] { 6 };
MyByteArray = new byte[] { 7 };
MySByteArray = new sbyte[] { 8 };
MyCharArray = new char[] { 'a' };
MyStringArray = new string[] { "Hello" };
MyBooleanTrueArray = new bool[] { true };
MyBooleanFalseArray = new bool[] { false };
MySingleArray = new float[] { 1.1f };
MyDoubleArray = new double[] { 2.2d };
MyDecimalArray = new decimal[] { 3.3m };
MyDateTimeArray = new DateTime[] { new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc) };
MyDateTimeOffsetArray = new DateTimeOffset[] { new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)) };
MyGuidArray = new Guid[] { new Guid("1B33498A-7B7D-4DDA-9C13-F6AA4AB449A6") };
MyUriArray = new Uri[] { new Uri("https://github.com/dotnet/corefx") };
MyEnumArray = new SampleEnum[] { SampleEnum.Two };
MyInt16TwoDimensionArray = new int[2][];
MyInt16TwoDimensionArray[0] = new int[] { 10, 11 };
MyInt16TwoDimensionArray[1] = new int[] { 20, 21 };
MyInt16TwoDimensionList = new List <List <int> >();
MyInt16TwoDimensionList.Add(new List <int> {
10, 11
});
MyInt16TwoDimensionList.Add(new List <int> {
20, 21
});
MyInt16ThreeDimensionArray = new int[2][][];
MyInt16ThreeDimensionArray[0] = new int[2][];
MyInt16ThreeDimensionArray[1] = new int[2][];
MyInt16ThreeDimensionArray[0][0] = new int[] { 11, 12 };
MyInt16ThreeDimensionArray[0][1] = new int[] { 13, 14 };
MyInt16ThreeDimensionArray[1][0] = new int[] { 21, 22 };
MyInt16ThreeDimensionArray[1][1] = new int[] { 23, 24 };
MyInt16ThreeDimensionList = new List <List <List <int> > >();
var list1 = new List <List <int> >();
MyInt16ThreeDimensionList.Add(list1);
list1.Add(new List <int> {
11, 12
});
list1.Add(new List <int> {
13, 14
});
var list2 = new List <List <int> >();
MyInt16ThreeDimensionList.Add(list2);
list2.Add(new List <int> {
21, 22
});
list2.Add(new List <int> {
23, 24
});
MyStringList = new List <string>()
{
"Hello"
};
MyStringIEnumerable = new string[] { "Hello" };
MyStringIList = new string[] { "Hello" };
MyStringICollection = new string[] { "Hello" };
MyStringIEnumerableT = new string[] { "Hello" };
MyStringIListT = new string[] { "Hello" };
MyStringICollectionT = new string[] { "Hello" };
MyStringIReadOnlyCollectionT = new string[] { "Hello" };
MyStringIReadOnlyListT = new string[] { "Hello" };
MyStringISetT = new HashSet <string> {
"Hello"
};
//MyStringToStringKeyValuePair = new KeyValuePair<string, string>("myKey", "myValue");
MyStringToStringIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringGenericDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringGenericIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringGenericIReadOnlyDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringImmutableDict = ImmutableDictionary.CreateRange(MyStringToStringGenericDict);
MyStringToStringIImmutableDict = ImmutableDictionary.CreateRange(MyStringToStringGenericDict);
MyStringToStringImmutableSortedDict = ImmutableSortedDictionary.CreateRange(MyStringToStringGenericDict);
MyStringStackT = new Stack <string>(new List <string>()
{
"Hello", "World"
});
MyStringQueueT = new Queue <string>(new List <string>()
{
"Hello", "World"
});
MyStringHashSetT = new HashSet <string>(new List <string>()
{
"Hello"
});
MyStringLinkedListT = new LinkedList <string>(new List <string>()
{
"Hello"
});
MyStringSortedSetT = new SortedSet <string>(new List <string>()
{
"Hello"
});
MyStringIImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableHashSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringImmutablQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableSortedSetT = ImmutableSortedSet.CreateRange(new List <string> {
"Hello"
});
MyListOfNullString = new List <string> {
null
};
}
internal static ThrownExceptionInfo Create(BasicBlock block, INamedTypeSymbol exceptionType, ImmutableStack <IOperation>?interproceduralCallStackOpt)
{
return(new ThrownExceptionInfo(block, exceptionType, interproceduralCallStackOpt, isDefaultExceptionForExceptionsPathAnalysis: false));
}
internal ThrownExceptionInfo With(BasicBlock block, ImmutableStack <IOperation>?interproceduralCallStackOpt)
{
Debug.Assert(interproceduralCallStackOpt != InterproceduralCallStack);
return(new ThrownExceptionInfo(block, ExceptionType, interproceduralCallStackOpt, IsDefaultExceptionForExceptionsPathAnalysis));
}
public static AbstractLocation CreateSymbolLocation(ISymbol symbol, ImmutableStack <IOperation> creationCallStackOpt) => Create(creationOpt: null, creationCallStackOpt: creationCallStackOpt, analysisEntityOpt: null, symbolOpt: symbol, captureIdOpt: null, locationType: symbol.GetMemberOrLocalOrParameterType());
/// <summary> /// Initializes a new <see cref="Verifier"/>. /// </summary> /// <param name="context">The context stack to include.</param> private Verifier(ImmutableStack <String> context) => Context = context;
public void Initialize()
{
MyInt16 = 1;
MyInt32 = 2;
MyInt64 = 3;
MyUInt16 = 4;
MyUInt32 = 5;
MyUInt64 = 6;
MyByte = 7;
MySByte = 8;
MyChar = 'a';
MyString = "Hello";
MyBooleanTrue = true;
MyBooleanFalse = false;
MySingle = 1.1f;
MyDouble = 2.2d;
MyDecimal = 3.3m;
MyDateTime = new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc);
MyDateTimeOffset = new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0));
MyEnum = SampleEnum.Two;
MyInt16Array = new short[] { 1 };
MyInt32Array = new int[] { 2 };
MyInt64Array = new long[] { 3 };
MyUInt16Array = new ushort[] { 4 };
MyUInt32Array = new uint[] { 5 };
MyUInt64Array = new ulong[] { 6 };
MyByteArray = new byte[] { 7 };
MySByteArray = new sbyte[] { 8 };
MyCharArray = new char[] { 'a' };
MyStringArray = new string[] { "Hello" };
MyBooleanTrueArray = new bool[] { true };
MyBooleanFalseArray = new bool[] { false };
MySingleArray = new float[] { 1.1f };
MyDoubleArray = new double[] { 2.2d };
MyDecimalArray = new decimal[] { 3.3m };
MyDateTimeArray = new DateTime[] { new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc) };
MyDateTimeOffsetArray = new DateTimeOffset[] { new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)) };
MyEnumArray = new SampleEnum[] { SampleEnum.Two };
MyStringList = new List <string>()
{
"Hello"
};
MyStringIEnumerableT = new string[] { "Hello" };
MyStringIListT = new string[] { "Hello" };
MyStringICollectionT = new string[] { "Hello" };
MyStringIReadOnlyCollectionT = new string[] { "Hello" };
MyStringIReadOnlyListT = new string[] { "Hello" };
MyStringToStringDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringIReadOnlyDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringStackT = new Stack <string>(new List <string>()
{
"Hello", "World"
});
MyStringQueueT = new Queue <string>(new List <string>()
{
"Hello", "World"
});
MyStringHashSetT = new HashSet <string>(new List <string>()
{
"Hello"
});
MyStringLinkedListT = new LinkedList <string>(new List <string>()
{
"Hello"
});
MyStringSortedSetT = new SortedSet <string>(new List <string>()
{
"Hello"
});
MyStringIImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableHashSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringImmutablQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableSortedSetT = ImmutableSortedSet.CreateRange(new List <string> {
"Hello"
});
MyListOfNullString = new List <string> {
null
};
}
/// <summary>
/// Pops the stacked input handler (and all input handlers above it).
/// If <paramref name="inputHandler"/> is not found in the currently stacked input handlers, or is null, this method
/// does nothing.
/// </summary>
/// <remarks><inheritdoc cref="ITextAreaInputHandler"/></remarks>
public void PopStackedInputHandler(TextAreaStackedInputHandler inputHandler)
{
if (stackedInputHandlers.Any(i => i == inputHandler)) {
ITextAreaInputHandler oldHandler;
do {
oldHandler = stackedInputHandlers.Peek();
stackedInputHandlers = stackedInputHandlers.Pop();
oldHandler.Detach();
} while (oldHandler != inputHandler);
}
}
public static void ArrayAsRootObject()
{
const string ExpectedJson = @"[1,true,{""City"":""MyCity""},null,""foo""]";
const string ReversedExpectedJson = @"[""foo"",null,{""City"":""MyCity""},true,1]";
string[] expectedObjects = { @"""foo""", @"null", @"{""City"":""MyCity""}", @"true", @"1" };
var address = new Address();
address.Initialize();
var array = new object[] { 1, true, address, null, "foo" };
string json = JsonSerializer.Serialize(array);
Assert.Equal(ExpectedJson, json);
var dictionary = new Dictionary <string, string> {
{ "City", "MyCity" }
};
var arrayWithDictionary = new object[] { 1, true, dictionary, null, "foo" };
json = JsonSerializer.Serialize(arrayWithDictionary);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(array);
Assert.Equal(ExpectedJson, json);
List <object> list = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(list);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(list);
Assert.Equal(ExpectedJson, json);
IEnumerable ienumerable = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(ienumerable);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(ienumerable);
Assert.Equal(ExpectedJson, json);
IList ilist = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(ilist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(ilist);
Assert.Equal(ExpectedJson, json);
ICollection icollection = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(icollection);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(icollection);
Assert.Equal(ExpectedJson, json);
IEnumerable <object> genericIEnumerable = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIEnumerable);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIEnumerable);
Assert.Equal(ExpectedJson, json);
IList <object> genericIList = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIList);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIList);
Assert.Equal(ExpectedJson, json);
ICollection <object> genericICollection = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericICollection);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericICollection);
Assert.Equal(ExpectedJson, json);
IReadOnlyCollection <object> genericIReadOnlyCollection = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIReadOnlyCollection);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIReadOnlyCollection);
Assert.Equal(ExpectedJson, json);
IReadOnlyList <object> genericIReadonlyList = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIReadonlyList);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIReadonlyList);
Assert.Equal(ExpectedJson, json);
ISet <object> iset = new HashSet <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(iset);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(iset);
Assert.Equal(ExpectedJson, json);
Stack <object> stack = new Stack <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(stack);
Assert.Equal(ReversedExpectedJson, json);
json = JsonSerializer.Serialize <object>(stack);
Assert.Equal(ReversedExpectedJson, json);
Queue <object> queue = new Queue <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(queue);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(queue);
Assert.Equal(ExpectedJson, json);
HashSet <object> hashset = new HashSet <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(hashset);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(hashset);
Assert.Equal(ExpectedJson, json);
LinkedList <object> linkedlist = new LinkedList <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(linkedlist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(linkedlist);
Assert.Equal(ExpectedJson, json);
ImmutableArray <object> immutablearray = ImmutableArray.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablearray);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablearray);
Assert.Equal(ExpectedJson, json);
IImmutableList <object> iimmutablelist = ImmutableList.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutablelist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(iimmutablelist);
Assert.Equal(ExpectedJson, json);
IImmutableStack <object> iimmutablestack = ImmutableStack.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutablestack);
Assert.Equal(ReversedExpectedJson, json);
json = JsonSerializer.Serialize <object>(iimmutablestack);
Assert.Equal(ReversedExpectedJson, json);
IImmutableQueue <object> iimmutablequeue = ImmutableQueue.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutablequeue);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(iimmutablequeue);
Assert.Equal(ExpectedJson, json);
IImmutableSet <object> iimmutableset = ImmutableHashSet.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutableset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
json = JsonSerializer.Serialize <object>(iimmutableset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
ImmutableHashSet <object> immutablehashset = ImmutableHashSet.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablehashset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
json = JsonSerializer.Serialize <object>(immutablehashset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
ImmutableList <object> immutablelist = ImmutableList.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablelist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablelist);
Assert.Equal(ExpectedJson, json);
ImmutableStack <object> immutablestack = ImmutableStack.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablestack);
Assert.Equal(ReversedExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablestack);
Assert.Equal(ReversedExpectedJson, json);
ImmutableQueue <object> immutablequeue = ImmutableQueue.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablequeue);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablequeue);
Assert.Equal(ExpectedJson, json);
}
/// <summary>
/// Adds a new variable or lambda parameter to the current block.
/// </summary>
public void AddVariable(IVariable variable)
{
if (variable == null)
throw new ArgumentNullException("variable");
localVariableStack = localVariableStack.Push(variable);
}
public void Push(ActionQueue actionQueue)
{
_callStack = _callStack.Push(actionQueue);
}
/// <summary>
/// Opens a new scope for local variables.
/// </summary>
public void PushBlock()
{
localVariableStack = localVariableStack.Push(null);
}
public FluentAssertionsCSharpSyntaxVisitor(params MemberValidator[] members)
{
AllMembers = ImmutableStack.Create(members);
Members = AllMembers;
}
