public void SmallDictionaryAlwaysBalanced() { var sd = new SmallDictionary<int, string>(); sd.Add(1, "1"); sd.AssertBalanced(); sd.Add(10, "1"); sd.AssertBalanced(); sd.Add(2, "1"); sd.AssertBalanced(); sd.Add(1000, "1"); sd.AssertBalanced(); sd.Add(-123, "1"); sd.AssertBalanced(); sd.Add(0, "1"); sd.AssertBalanced(); sd.Add(4, "1"); sd.AssertBalanced(); sd.Add(5, "1"); sd.AssertBalanced(); sd.Add(6, "1"); sd.AssertBalanced(); }
public void ThreeItems() { var dict = new SmallDictionary<int, string>(); dict[2] = "abc"; dict[5] = "def"; dict[11] = "third"; Assert.AreEqual(3, dict.Count); Assert.AreEqual("abc", dict[2]); Assert.AreEqual("def", dict[5]); Assert.AreEqual("third", dict[11]); string output; Assert.IsFalse(dict.TryGetValue(3, out output)); Assert.IsNull(output); Assert.IsTrue(dict.TryGetValue(2, out output)); Assert.AreEqual("abc", output); Assert.IsTrue(dict.TryGetValue(5, out output)); Assert.AreEqual("def", output); Assert.IsTrue(dict.TryGetValue(11, out output)); Assert.AreEqual("third", output); Assert.IsFalse(dict.ContainsKey(3)); Assert.IsTrue(dict.ContainsKey(2)); Assert.IsTrue(dict.ContainsKey(5)); Assert.IsTrue(dict.ContainsKey(11)); }
internal WithPrimaryConstructorParametersBinder(MethodSymbol primaryCtor, Binder next) : base(next) { Debug.Assert((object)primaryCtor != null); this.primaryCtor = primaryCtor; var parameters = primaryCtor.Parameters; var definitionMap = new SmallDictionary<string, ParameterSymbol>(); for (int i = parameters.Length - 1; i >= 0; i--) { var parameter = parameters[i]; definitionMap[parameter.Name] = parameter; } this.definitionMap = definitionMap; var parameterMap = new MultiDictionary<string, ParameterSymbol>(parameters.Length, EqualityComparer<string>.Default); foreach (var parameter in parameters) { parameterMap.Add(parameter.Name, parameter); } this.parameterMap = parameterMap; }
private LocalBinderFactory(MethodSymbol method, Binder enclosing) { Debug.Assert((object)method != null); _map = new SmallDictionary<CSharpSyntaxNode, Binder>(ReferenceEqualityComparer.Instance); _method = method; _enclosing = enclosing; }
public void TestSmallDict() { var ht = new SmallDictionary<int, int>(); const int elements = 150; for (int i = 0; i < elements; i += 10) { ht.Add(i, i); ht.AssertBalanced(); ht.Add(i - 2, i - 2); ht.AssertBalanced(); ht.Add(i - 3, i - 3); ht.AssertBalanced(); ht.Add(i - 4, i - 4); ht.AssertBalanced(); ht.Add(i - 6, i - 6); ht.AssertBalanced(); ht.Add(i - 5, i - 5); ht.AssertBalanced(); ht.Add(i - 1, i - 1); ht.AssertBalanced(); ht.Add(i - 7, i - 7); ht.AssertBalanced(); ht.Add(i - 8, i - 8); ht.AssertBalanced(); ht.Add(i - 9, i - 9); ht.AssertBalanced(); } Assert.Equal(150, ht.Count()); for (int i = 0; i < elements; i += 10) { Assert.Equal(ht[i], i); Assert.Equal(ht[i - 2], i - 2); Assert.Equal(ht[i - 3], i - 3); Assert.Equal(ht[i - 4], i - 4); Assert.Equal(ht[i - 6], i - 6); Assert.Equal(ht[i - 5], i - 5); Assert.Equal(ht[i - 1], i - 1); Assert.Equal(ht[i - 7], i - 7); Assert.Equal(ht[i - 8], i - 8); Assert.Equal(ht[i - 9], i - 9); } foreach (var p in ht) { Assert.Equal(p.Key, p.Value); } var keys = ht.Keys.ToArray(); var values = ht.Values.ToArray(); for (int i = 0, l = ht.Count(); i < l; i++) { Assert.Equal(keys[i], values[i]); } }
internal void AddDeclaration(string name, SemanticModelInfo info) { if (locals == null) { locals = new SmallDictionary<string, SemanticModelInfo>(); } locals[name] = info; }
public void Empty() { var dict = new SmallDictionary<int, string>(); Assert.AreEqual(0, dict.Count); string output; Assert.IsFalse(dict.TryGetValue(2, out output)); Assert.IsNull(output); Assert.IsFalse(dict.ContainsKey(3)); }
private void RecordDefinitions(ImmutableArray<ParameterSymbol> definitions) { var declarationMap = _definitionMap ?? (_definitionMap = new SmallDictionary<string, ParameterSymbol>()); foreach (var s in definitions) { if (!declarationMap.ContainsKey(s.Name)) { declarationMap.Add(s.Name, s); } } }
internal ILBuilder(ITokenDeferral module, LocalSlotManager localSlotManager, OptimizationLevel optimizations) { Debug.Assert(BitConverter.IsLittleEndian); this.module = module; this.LocalSlotManager = localSlotManager; _emitState = default(EmitState); _scopeManager = new LocalScopeManager(); leaderBlock = _currentBlock = _scopeManager.CreateBlock(this); _labelInfos = new SmallDictionary<object, LabelInfo>(ReferenceEqualityComparer.Instance); _optimizations = optimizations; }
internal ILBuilder(ITokenDeferral module, LocalSlotManager localSlotManager, bool isOptimizing) { Debug.Assert(BitConverter.IsLittleEndian); this.module = module; this.LocalSlotManager = localSlotManager; this.emitState = default(EmitState); this.scopeManager = new LocalScopeManager(); leaderBlock = currentBlock = this.scopeManager.CreateBlock(this); labelInfos = new SmallDictionary<object, LabelInfo>(ReferenceEqualityComparer.Instance); this.isOptimizing = isOptimizing; }
public void OneItem() { var dict = new SmallDictionary<int, string>(); dict[2] = "abc"; Assert.AreEqual(1, dict.Count); Assert.AreEqual("abc", dict[2]); string output; Assert.IsFalse(dict.TryGetValue(3, out output)); Assert.IsNull(output); Assert.IsTrue(dict.TryGetValue(2, out output)); Assert.AreEqual("abc", output); Assert.IsFalse(dict.ContainsKey(3)); Assert.IsTrue(dict.ContainsKey(2)); }
private static SmallDictionary <string, TSymbol> BuildMap <TSymbol>(ImmutableArray <TSymbol> array) where TSymbol : Symbol { Debug.Assert(array.Length > 0); var map = new SmallDictionary <string, TSymbol>(); // NOTE: in a rare case of having two symbols with same name the one closer to the array's start wins. for (int i = array.Length - 1; i >= 0; i--) { var symbol = array[i]; map[symbol.Name] = symbol; } return(map); }
public void TestSmallDict() { var ht = new SmallDictionary<int, int>(); const int elements = 150; for (int i = 0; i < elements; i += 4) { ht.Add(i, i); ht.Add(i - 1, i - 1); ht.Add(i - 2, i - 2); ht.Add(i - 3, i - 3); } Assert.Equal(152, ht.Count()); for (int j = 0; j < 100; j++) { for (int i = 0; i < elements; i += 4) { int v; ht.TryGetValue(i, out v); Assert.Equal(i, v); ht.TryGetValue(i - 1, out v); Assert.Equal(i - 1, v); ht.TryGetValue(i - 2, out v); Assert.Equal(i - 2, v); ht.TryGetValue(i - 3, out v); Assert.Equal(i - 3, v); } } foreach(var p in ht) { Assert.Equal(p.Key, p.Value); } var keys = ht.Keys.ToArray(); var values = ht.Values.ToArray(); for (int i = 0, l = ht.Count(); i < l; i++) { Assert.Equal(keys[i], values[i]); } }
public void TestSmallDict() { var ht = new SmallDictionary <int, int>(); const int elements = 150; for (int i = 0; i < elements; i += 4) { ht.Add(i, i); ht.Add(i - 1, i - 1); ht.Add(i - 2, i - 2); ht.Add(i - 3, i - 3); } Assert.Equal(152, ht.Count()); for (int j = 0; j < 100; j++) { for (int i = 0; i < elements; i += 4) { int v; ht.TryGetValue(i, out v); Assert.Equal(i, v); ht.TryGetValue(i - 1, out v); Assert.Equal(i - 1, v); ht.TryGetValue(i - 2, out v); Assert.Equal(i - 2, v); ht.TryGetValue(i - 3, out v); Assert.Equal(i - 3, v); } } foreach (var p in ht) { Assert.Equal(p.Key, p.Value); } var keys = ht.Keys.ToArray(); var values = ht.Values.ToArray(); for (int i = 0, l = ht.Count(); i < l; i++) { Assert.Equal(keys[i], values[i]); } }
public Enumerator(SmallDictionary <K, V> dict) : this() { var root = dict._root; if (root != null) { // left == right only if both are nulls if (root.Left == root.Right) { _next = root; } else { _stack = new Stack <AvlNode>(dict.HeightApprox()); _stack.Push(root); } } }
private LocalBinderFactory( Symbol containingMemberOrLambda, SyntaxNode root, Binder enclosing ) { Debug.Assert((object)containingMemberOrLambda != null); Debug.Assert( containingMemberOrLambda.Kind != SymbolKind.Local && containingMemberOrLambda.Kind != SymbolKind.RangeVariable && containingMemberOrLambda.Kind != SymbolKind.Parameter ); _map = new SmallDictionary <SyntaxNode, Binder>(ReferenceEqualityComparer.Instance); _containingMemberOrLambda = containingMemberOrLambda; _enclosing = enclosing; _root = root; }
public override void InitializeTupleFieldDefinitionsToIndexMap() { Debug.Assert(this.IsTupleType); Debug.Assert(this.IsDefinition); // we only store a map for definitions var retargetedMap = new SmallDictionary <FieldSymbol, int>( ReferenceEqualityComparer.Instance ); foreach ( (FieldSymbol field, int index) in _underlyingType.TupleFieldDefinitionsToIndexMap ) { retargetedMap.Add(this.RetargetingTranslator.Retarget(field), index); } this.TupleData !.SetFieldDefinitionsToIndexMap(retargetedMap); }
private static SmallDictionary <TypeParameterSymbol, TypeSymbolWithAnnotations> ConstructMapping(ImmutableArray <TypeParameterSymbol> from, ImmutableArray <TypeSymbolWithAnnotations> to) { var mapping = new SmallDictionary <TypeParameterSymbol, TypeSymbolWithAnnotations>(ReferenceEqualityComparer.Instance); Debug.Assert(from.Length == to.Length); for (int i = 0; i < from.Length; i++) { TypeParameterSymbol tp = from[i]; TypeSymbolWithAnnotations ta = to[i]; if (!ta.Is(tp)) { mapping.Add(tp, ta); } } return(mapping); }
/// <summary> /// Report an error if adding the edge (method1, method2) to the ctor-initializer /// graph would add a new cycle to that graph. /// </summary> /// <param name="method1">a calling ctor</param> /// <param name="method2">the chained-to ctor</param> /// <param name="syntax">where to report a cyclic error if needed</param> /// <param name="diagnostics">a diagnostic bag for receiving the diagnostic</param> internal void ReportCtorInitializerCycles(MethodSymbol method1, MethodSymbol method2, CSharpSyntaxNode syntax, DiagnosticBag diagnostics) { // precondition and postcondition: the graph _constructorInitializers is acyclic. // If adding the edge (method1, method2) would induce a cycle, we report an error // and do not add it to the set of edges. If it would not induce a cycle we add // it to the set of edges and return. if (method1 == method2) { // direct recursion is diagnosed elsewhere throw ExceptionUtilities.Unreachable; } if (_constructorInitializers == null) { _constructorInitializers = new SmallDictionary <MethodSymbol, MethodSymbol>(); _constructorInitializers.Add(method1, method2); return; } MethodSymbol next = method2; while (true) { if (_constructorInitializers.TryGetValue(next, out next)) { Debug.Assert((object)next != null); if (method1 == next) { // We found a (new) cycle containing the edge (method1, method2). Report an // error and do not add the edge. diagnostics.Add(ErrorCode.ERR_IndirectRecursiveConstructorCall, syntax.Location, method1); return; } } else { // we've reached the end of the path without finding a cycle. Add the new edge. _constructorInitializers.Add(method1, method2); return; } } }
internal ILBuilder( ITokenDeferral module, LocalSlotManager localSlotManager, OptimizationLevel optimizations, bool areLocalsZeroed ) { Debug.Assert(BitConverter.IsLittleEndian); this.module = module; this.LocalSlotManager = localSlotManager; _emitState = default(EmitState); _scopeManager = new LocalScopeManager(); leaderBlock = _currentBlock = _scopeManager.CreateBlock(this); _labelInfos = new SmallDictionary <object, LabelInfo>( ReferenceEqualityComparer.Instance ); _optimizations = optimizations; _areLocalsZeroed = areLocalsZeroed; }
internal static SmallDictionary <TypeParameterSymbol, bool> BuildIsValueTypeMap( Symbol container, ImmutableArray <TypeParameterSymbol> typeParameters, ImmutableArray <TypeParameterConstraintClause> constraintClauses ) { Debug.Assert(constraintClauses.Length == typeParameters.Length); var isValueTypeMap = new SmallDictionary <TypeParameterSymbol, bool>( ReferenceEqualityComparer.Instance ); foreach (TypeParameterSymbol typeParameter in typeParameters) { isValueType( typeParameter, constraintClauses, isValueTypeMap, ConsList <TypeParameterSymbol> .Empty ); } return(isValueTypeMap);
private bool TryOptimizeSameAsNext(BasicBlock next, ref int delta) { if (next.HasNoRegularInstructions && next.BranchCode == this.BranchCode && next.BranchBlock.Start == this.BranchBlock.Start) { if (next.EnclosingHandler == this.EnclosingHandler) { int diff = this.BranchCode.Size() + this.BranchCode.GetBranchOperandSize(); delta -= diff; this.SetBranch(null, ILOpCode.Nop); // If current block has no regular instructions the resulting block is a trivial noop // TryOptimizeBranchOverUncondBranch relies on an invariant that // trivial blocks are not targeted by branches, // make sure we are not breaking this condition. if (this.HasNoRegularInstructions) { SmallDictionary <object, LabelInfo> labelInfos = builder._labelInfos; SmallDictionary <object, LabelInfo> .KeyCollection labels = labelInfos.Keys; foreach (object label in labels) { LabelInfo info = labelInfos[label]; if (info.bb == this) { // move the label from "this" to "next" labelInfos[label] = info.WithNewTarget(next); } } } return(true); } } return(false); }
/// <summary> /// Report an error if adding the edge (method1, method2) to the ctor-initializer /// graph would add a new cycle to that graph. /// </summary> /// <param name="method1">a calling ctor</param> /// <param name="method2">the chained-to ctor</param> /// <param name="syntax">where to report a cyclic error if needed</param> /// <param name="diagnostics">a diagnostic bag for receiving the diagnostic</param> internal void ReportCtorInitializerCycles(MethodSymbol method1, MethodSymbol method2, SyntaxNode syntax, DiagnosticBag diagnostics) { // precondition and postcondition: the graph _constructorInitializers is acyclic. // If adding the edge (method1, method2) would induce a cycle, we report an error // and do not add it to the set of edges. If it would not induce a cycle we add // it to the set of edges and return. if (method1 == method2) { // direct recursion is diagnosed elsewhere throw ExceptionUtilities.Unreachable; } if (_constructorInitializers == null) { _constructorInitializers = new SmallDictionary<MethodSymbol, MethodSymbol>(); _constructorInitializers.Add(method1, method2); return; } MethodSymbol next = method2; while (true) { if (_constructorInitializers.TryGetValue(next, out next)) { Debug.Assert((object)next != null); if (method1 == next) { // We found a (new) cycle containing the edge (method1, method2). Report an // error and do not add the edge. diagnostics.Add(ErrorCode.ERR_IndirectRecursiveConstructorCall, syntax.Location, method1); return; } } else { // we've reached the end of the path without finding a cycle. Add the new edge. _constructorInitializers.Add(method1, method2); return; } } }
public void Overwrite() { var dict = new SmallDictionary<int, string>(); dict[2] = "abc"; Assert.AreEqual("abc", dict[2]); dict[2] = "first"; Assert.AreEqual("first", dict[2]); Assert.AreEqual(1, dict.Count); dict[5] = "def"; dict[11] = "third"; Assert.AreEqual(3, dict.Count); Assert.AreEqual("first", dict[2]); Assert.AreEqual("def", dict[5]); Assert.AreEqual("third", dict[11]); dict[5] = "second"; Assert.AreEqual(3, dict.Count); Assert.AreEqual("first", dict[2]); Assert.AreEqual("second", dict[5]); Assert.AreEqual("third", dict[11]); dict[11] = "change"; Assert.AreEqual(3, dict.Count); Assert.AreEqual("first", dict[2]); Assert.AreEqual("second", dict[5]); Assert.AreEqual("change", dict[11]); }
/// <summary> Free resources allocated for this method collection </summary> public void Free() { if (_synthesizedMethods != null) { _synthesizedMethods.Free(); _synthesizedMethods = null; } _wrappers = null; _constructorInitializers = null; }
public TsMultiString() { m_strings = new SmallDictionary <int, ITsString>(); }
private TypeMap(SmallDictionary <TypeParameterSymbol, TypeSymbolWithAnnotations> mapping) : base(new SmallDictionary <TypeParameterSymbol, TypeSymbolWithAnnotations>(mapping, ReferenceEqualityComparer.Instance)) { // mapping contents are read-only hereafter }
public PlatformAttributes(Callsite callsite, SmallDictionary <string, Versions> platforms) { Callsite = callsite; Platforms = platforms; }
internal TypeMap(SmallDictionary<TypeParameterSymbol, TypeWithModifiers> mapping) : base(new SmallDictionary<TypeParameterSymbol, TypeWithModifiers>(mapping, ReferenceEqualityComparer.Instance)) { // mapping contents are read-only hereafter Debug.Assert(!mapping.Keys.Any(tp => tp is SubstitutedTypeParameterSymbol)); }
public void Remove() { var dict = new SmallDictionary<int, string>(); Assert.IsFalse(dict.Remove(2), "Remove a missing item from an empty dictionary"); dict.Add(2, "abc"); Assert.IsFalse(dict.Remove(3), "Remove a missing item from a dictionary with one item"); Assert.IsTrue(dict.Remove(2), "Remove the only item from a dictionary"); Assert.AreEqual(0, dict.Count, "Nothing remains after removing the only item"); dict.Add(2, "abc"); dict.Add(5, "def"); dict.Add(11, "third"); Assert.IsFalse(dict.Remove(7), "Remove a missing item from a dictionary with three items"); Assert.IsTrue(dict.Remove(2), "Remove the first item from a dictionary with three items"); Assert.AreEqual(2, dict.Count, "Two items remain after removing the first of three"); string output; Assert.IsFalse(dict.TryGetValue(2, out output), "Removed item (first) should be gone from original three"); Assert.AreEqual("def", dict[5]); Assert.AreEqual("third", dict[11]); dict.Add(2, "abc"); Assert.IsTrue(dict.Remove(5), "Remove first of two items in others"); Assert.AreEqual(2, dict.Count); Assert.IsFalse(dict.TryGetValue(5, out output)); Assert.AreEqual("abc", dict[2]); Assert.AreEqual("third", dict[11]); Assert.IsTrue(dict.Remove(2), "Remove only item in others"); Assert.AreEqual(1, dict.Count); Assert.IsFalse(dict.TryGetValue(2, out output)); Assert.AreEqual("third", dict[11]); Assert.IsTrue(dict.Remove(11), "Remove only item in dictionary which previously had three"); Assert.AreEqual(0, dict.Count); Assert.IsFalse(dict.TryGetValue(11, out output)); dict.Add(2, "abc"); dict.Add(5, "def"); dict.Add(11, "third"); dict.Add(13, "fourth"); Assert.IsTrue(dict.Remove(11), "Remove middle of three items in others"); Assert.AreEqual(3, dict.Count); Assert.IsFalse(dict.TryGetValue(11, out output)); Assert.AreEqual("abc", dict[2]); Assert.AreEqual("def", dict[5]); Assert.AreEqual("fourth", dict[13]); Assert.IsTrue(dict.Remove(13), "Remove last of two items in others"); Assert.AreEqual(2, dict.Count); Assert.IsFalse(dict.TryGetValue(13, out output)); Assert.AreEqual("abc", dict[2]); Assert.AreEqual("def", dict[5]); Assert.IsTrue(dict.Remove(2), "Remove first item when others contains exactly one"); Assert.AreEqual(1, dict.Count); Assert.IsFalse(dict.TryGetValue(2, out output)); Assert.AreEqual("def", dict[5]); }
private TypeMap(SmallDictionary<TypeParameterSymbol, TypeWithModifiers> mapping) : base(new SmallDictionary<TypeParameterSymbol, TypeWithModifiers>(mapping, ReferenceEqualityComparer.Instance)) { // mapping contents are read-only hereafter }
public void SmallDictionary() { IDictionary<string, int> dict = new SmallDictionary<string, int>(); DoTests(dict); }
public void Enumerator() { var dict = new SmallDictionary<int, string>(); foreach (var kvp in dict) { Assert.Fail("Should get no iterations looping over empty dictionary"); } dict.Add(2, "abc"); int count = 0; foreach (var kvp in dict) { count++; Assert.AreEqual(2, kvp.Key); Assert.AreEqual("abc", kvp.Value); } Assert.AreEqual(1,count); dict.Add(5, "def"); dict.Add(11, "third"); count = 0; Dictionary<int, string> normalDict = new Dictionary<int, string>(dict); Assert.AreEqual("abc", normalDict[2]); Assert.AreEqual("def", normalDict[5]); Assert.AreEqual("third", normalDict[11]); Assert.AreEqual(3, normalDict.Count); foreach (var kvp in dict) { count++; Assert.IsTrue(normalDict.ContainsKey(kvp.Key)); Assert.AreEqual(normalDict[kvp.Key], kvp.Value); normalDict.Remove(kvp.Key); } Assert.AreEqual(3, count); }
public void KeysAndValues() { var dict = new SmallDictionary<int, string>(); VerifyIntArrays(new int[0], dict.Keys.ToArray()); VerifyStringArrays(new string[0], dict.Values.ToArray()); dict.Add(2, "abc"); VerifyIntArrays(new int[] {2}, dict.Keys.ToArray()); VerifyStringArrays(new string[] {"abc"}, dict.Values.ToArray()); // This test is too strict, it enforces a particular order of the results. dict.Add(5, "def"); dict.Add(11, "third"); VerifyIntArrays(new int[] { 2, 5, 11 }, dict.Keys.ToArray()); VerifyStringArrays(new string[] { "abc", "def", "third" }, dict.Values.ToArray()); }
protected AbstractTypeParameterMap(SmallDictionary<TypeParameterSymbol, TypeSymbol> mapping) { this.Mapping = mapping; }
/// <summary> /// Constructs a unification with the given dictionary. /// </summary> /// <param name="dict"> /// The dictionary to use in construction. /// </param> internal ImmutableTypeMap(SmallDictionary <TypeParameterSymbol, TypeWithModifiers> dict) : base(new SmallDictionary <TypeParameterSymbol, TypeWithModifiers>(dict, EqualityComparer <TypeParameterSymbol> .Default)) { Debug.Assert(IsNormalised, "map should be normalised on construction"); }
private LocalBinderFactory(Symbol containingMemberOrLambda, SyntaxNode root, Binder enclosing, ArrayBuilder<SyntaxNode> methodsWithYields) { Debug.Assert((object)containingMemberOrLambda != null); Debug.Assert(containingMemberOrLambda.Kind != SymbolKind.Local && containingMemberOrLambda.Kind != SymbolKind.RangeVariable && containingMemberOrLambda.Kind != SymbolKind.Parameter); _map = new SmallDictionary<SyntaxNode, Binder>(ReferenceEqualityComparer.Instance); _containingMemberOrLambda = containingMemberOrLambda; _enclosing = enclosing; _methodsWithYields = methodsWithYields; _root = root; }
public void GetMissingKeyThree() { var dict = new SmallDictionary<int, string>(); dict.Add(2, "abc"); dict.Add(5, "def"); dict.Add(11, "third"); var temp = dict[3]; }
public void Add() { var dict = new SmallDictionary<int, string>(); dict.Add(2, "abc"); Assert.AreEqual(1, dict.Count); dict.Add(5,"def"); Assert.AreEqual(2, dict.Count); dict.Add(11,"third"); Assert.AreEqual(3, dict.Count); Assert.AreEqual("abc", dict[2]); Assert.AreEqual("def", dict[5]); Assert.AreEqual("third", dict[11]); }
public void SmallDictionary() { IDictionary <string, int> dict = new SmallDictionary <string, int>(); DoTests(dict); }
internal TypeMap(SmallDictionary <TypeParameterSymbol, TypeWithModifiers> mapping) : base(new SmallDictionary <TypeParameterSymbol, TypeWithModifiers>(mapping, ReferenceEqualityComparer.Instance)) { // mapping contents are read-only hereafter Debug.Assert(!mapping.Keys.Any(tp => tp is SubstitutedTypeParameterSymbol)); }
protected AbstractTypeParameterMap( SmallDictionary <TypeParameterSymbol, TypeWithAnnotations> mapping ) { this.Mapping = mapping; }
private static SmallDictionary<TypeParameterSymbol, TypeWithModifiers> ConstructMapping(ImmutableArray<TypeParameterSymbol> from, ImmutableArray<TypeWithModifiers> to) { var mapping = new SmallDictionary<TypeParameterSymbol, TypeWithModifiers>(ReferenceEqualityComparer.Instance); Debug.Assert(from.Length == to.Length); for (int i = 0; i < from.Length; i++) { TypeParameterSymbol tp = from[i]; TypeWithModifiers ta = to[i]; if (!ta.Is(tp)) { mapping.Add(tp, ta); } } return mapping; }
public void AddExistingKeyTwoKeys() { var dict = new SmallDictionary<int, string>(); dict.Add(2, "abc"); dict.Add(3, "def"); dict.Add(3, "def"); }
internal TypeMap(SmallDictionary <TypeParameterSymbol, TypeWithModifiers> mapping) : base(new SmallDictionary <TypeParameterSymbol, TypeWithModifiers>(mapping, ReferenceEqualityComparer.Instance)) { // mapping contents are read-only hereafter }
/// <summary> /// Constructs a unification with the given dictionary. /// </summary> /// <param name="dict"> /// The dictionary to use in construction. /// </param> internal ImmutableTypeMap(SmallDictionary <TypeParameterSymbol, TypeWithModifiers> dict) : base(new SmallDictionary <TypeParameterSymbol, TypeWithModifiers>(dict, EqualityComparer <TypeParameterSymbol> .Default)) { }
static bool isValueType(TypeParameterSymbol thisTypeParameter, ImmutableArray <TypeParameterConstraintClause> constraintClauses, SmallDictionary <TypeParameterSymbol, bool> isValueTypeMap, ConsList <TypeParameterSymbol> inProgress) { if (inProgress.ContainsReference(thisTypeParameter)) { return(false); } if (isValueTypeMap.TryGetValue(thisTypeParameter, out bool knownIsValueType)) { return(knownIsValueType); } TypeParameterConstraintClause constraintClause = constraintClauses[thisTypeParameter.Ordinal]; bool result = false; if ((constraintClause.Constraints & TypeParameterConstraintKind.AllValueTypeKinds) != 0) { result = true; } else { Symbol container = thisTypeParameter.ContainingSymbol; inProgress = inProgress.Prepend(thisTypeParameter); foreach (TypeWithAnnotations constraintType in constraintClause.ConstraintTypes) { TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType; if (type is TypeParameterSymbol typeParameter && (object)typeParameter.ContainingSymbol == (object)container) { if (isValueType(typeParameter, constraintClauses, isValueTypeMap, inProgress)) { result = true; break; } }
public KeyCollection(SmallDictionary <K, V> dict) { _dict = dict; }
public ValueCollection(SmallDictionary <K, V> dict) { _dict = dict; }
public void Clear() { var dict = new SmallDictionary<int, string>(); dict.Clear(); Assert.AreEqual(0, dict.Count); dict[2] = "abc"; dict.Clear(); Assert.AreEqual(0, dict.Count); dict[2] = "abc"; dict[5] = "def"; dict[11] = "third"; dict.Clear(); Assert.AreEqual(0, dict.Count); }
private void MakeMemberMissing(int member) { if (lazyMakeMemberMissingMap == null) { lazyMakeMemberMissingMap = new SmallDictionary<int, bool>(); } lazyMakeMemberMissingMap[member] = true; }
private ExpressionSyntax ParseExpressionExperimental(string text) { var experimentalFeatures = new SmallDictionary<string, string>(); // no experimental features to enable return SyntaxFactory.ParseExpression(text, options: CSharpParseOptions.Default.WithFeatures(experimentalFeatures)); }