public Tuple <IIntermediateClassType, IIntermediateInterfaceType> Build(Tuple <ParserCompiler, RuleSymbolBuilder, IIntermediateAssembly> input) { this.compiler = input.Item1; this.commonSymbol = input.Item2; this.assembly = input.Item3; INamespaceDeclaration targetSpace; var targetSpaceName = TypeSystemIdentifiers.GetDeclarationIdentifier(string.Format("{0}.Cst", this.assembly.DefaultNamespace.FullName)); if (!assembly.Namespaces.PathExists(targetSpaceName.Name)) { targetSpace = this.assembly.DefaultNamespace.Namespaces.Add("Cst"); } else { targetSpace = this.assembly.DefaultNamespace.Namespaces[targetSpaceName]; } var mutableTargetSpace = (IIntermediateNamespaceDeclaration)targetSpace; this.resultInterface = mutableTargetSpace.Parts.Add().Interfaces.Add("I{0}Rule", compiler.Source.Options.AssemblyName); this.resultClass = mutableTargetSpace.Parts.Add().Classes.Add("{0}RuleBase", compiler.Source.Options.AssemblyName); this.resultClass.AccessLevel = AccessLevelModifiers.Internal; this.resultClass.ImplementedInterfaces.ImplementInterfaceQuick(resultInterface); this.resultInterface.AccessLevel = AccessLevelModifiers.Public; this.interfaceContext = this.BuildContext(); this.interfaceParent = this.BuildParent(); this.classContextField = this.BuildClassContextField(); this.classParentField = this.BuildClassParentField(); this.classContext = BuildClassContext(); this.classParent = BuildClassParent(); this.resultClass.SpecialModifier = SpecialClassModifier.Abstract; return(Tuple.Create(resultClass, resultInterface)); }
public IGeneralGenericSignatureMemberUniqueIdentifier GetIdentifier(IIntermediateMethodSignatureMember member) { var internalHelper = member as _IIntermediateMethodSignatureMember; if (internalHelper == null) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.TypeParameters.Count, member.UserSpecificQualifier, member.Parameters.ParameterTypes.ToArray())); } else if (internalHelper.IsDisposed) { throw new InvalidOperationException(Utilities.Properties.Resources.ObjectStateThrowMessage); } else if (internalHelper.AreTypeParametersInitialized) { if (internalHelper.AreParametersInitialized) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.TypeParameters.Count, member.UserSpecificQualifier, member.Parameters.ParameterTypes.ToArray())); } else { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.TypeParameters.Count, member.UserSpecificQualifier)); } } else if (internalHelper.AreParametersInitialized) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.UserSpecificQualifier, member.Parameters.ParameterTypes.ToArray())); } else { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.UserSpecificQualifier)); } }
internal static IUnaryOperatorUniqueIdentifier GetUnaryOperatorIdentifier(ICliMetadataMethodDefinitionTableRow methodDef, IType owner, _ICliManager manager) { switch (methodDef.Name) { case CliCommon.UnaryOperatorNames.Decrement: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.Decrement)); case CliCommon.UnaryOperatorNames.False: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.EvaluatesToFalse)); case CliCommon.UnaryOperatorNames.Increment: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.Increment)); case CliCommon.UnaryOperatorNames.LogicalNot: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.LogicalInvert)); case CliCommon.UnaryOperatorNames.Negation: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.Negation)); case CliCommon.UnaryOperatorNames.OnesComplement: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.Complement)); case CliCommon.UnaryOperatorNames.Plus: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.Plus)); case CliCommon.UnaryOperatorNames.True: return(TypeSystemIdentifiers.GetUnaryOperatorIdentifier(CoercibleUnaryOperators.EvaluatesToTrue)); default: throw new InvalidOperationException(); } }
public IAssemblyUniqueIdentifier GetIdentifier(IIntermediateAssembly assembly) { //if (assembly.PublicKeyInfo == null || assembly.PublicKeyInfo.PublicToken.Token == null || assembly.PublicKeyInfo.PublicToken.Token.Length == 0) return(TypeSystemIdentifiers.GetAssemblyIdentifier(assembly.Name, assembly.AssemblyInformation.AssemblyVersion, assembly.AssemblyInformation.Culture)); //else // return TypeSystemIdentifiers.GetAssemblyIdentifier(assembly.Name, assembly.AssemblyInformation.AssemblyVersion, assembly.AssemblyInformation.Culture, assembly.PublicKeyInfo.PublicToken.Token); }
public IIntermediateInterfaceType Build(Tuple <ParserCompiler, CommonSymbolBuilder, IIntermediateAssembly> input) { this.compiler = input.Item1; this.rootSymbol = input.Item2; this.assembly = input.Item3; this._identityManager = (IIntermediateCliManager)this.assembly.IdentityManager; INamespaceDeclaration targetSpace; var targetSpaceName = TypeSystemIdentifiers.GetDeclarationIdentifier(string.Format("{0}.Cst", this.assembly.DefaultNamespace.FullName)); if (!assembly.Namespaces.PathExists(targetSpaceName.Name)) { targetSpace = this.assembly.DefaultNamespace.Namespaces.Add("Cst"); } else { targetSpace = this.assembly.DefaultNamespace.Namespaces[targetSpaceName]; } var mutableTargetSpace = (IIntermediateNamespaceDeclaration)targetSpace; this.resultInterface = mutableTargetSpace.Parts.Add().Interfaces.Add("I{0}Token", compiler.Source.Options.AssemblyName); this.resultInterface.ImplementedInterfaces.Add(this.rootSymbol.ILanguageSymbol); this.resultInterface.AccessLevel = AccessLevelModifiers.Public; this.BuildStartPosition(); this.BuildEndPosition(); this.BuildStartTokenIndex(); return(this.resultInterface); }
public IGeneralSignatureMemberUniqueIdentifier GetIdentifier(IIntermediateConstructorSignatureMember member) { var internalHelper = member as _IntermediateConstructorSignatureMember; if (internalHelper == null) { return(TypeSystemIdentifiers.GetCtorSignatureIdentifier(member.Parameters.ParameterTypes.ToArray())); } else if (internalHelper.IsDisposed) { throw new InvalidOperationException(Utilities.Properties.Resources.ObjectStateThrowMessage); } else if (internalHelper.IsTypeInitializer) { return(TypeSystemIdentifiers.GetCtorSignatureIdentifier()); } else if (internalHelper.AreParametersInitialized) { return(TypeSystemIdentifiers.GetCtorSignatureIdentifier(member.Parameters.ParameterTypes.ToArray())); } else { return(TypeSystemIdentifiers.GetCtorSignatureIdentifier(new IType[0])); } }
private static IGeneralGenericSignatureMemberUniqueIdentifier GetIdentifierInternal(IIntermediateMethodMember member, _IIntermediateMethodSignatureMember internalHelper, IType firstImpl) { if (internalHelper == null) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.TypeParameters.Count, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier), member.Parameters.ParameterTypes.ToArray())); } else if (internalHelper.IsDisposed) { throw new InvalidOperationException(Utilities.Properties.Resources.ObjectStateThrowMessage); } else if (internalHelper.AreTypeParametersInitialized) { if (internalHelper.AreParametersInitialized) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.TypeParameters.Count, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier), member.Parameters.ParameterTypes.ToArray())); } else { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, member.TypeParameters.Count, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier), new IType[0])); } } else if (internalHelper.AreParametersInitialized) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, 0, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier), member.Parameters.ParameterTypes.ToArray())); } else { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(member.Name, 0, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier), new IType[0])); } }
public IGeneralMemberUniqueIdentifier GetIdentifier(IIntermediatePropertySignatureMember member) { if (member is IIntermediateClassPropertyMember || member is IIntermediateStructPropertyMember) { var classProp = member as IIntermediateClassPropertyMember; if (classProp != null) { var firstImpl = classProp.Implementations.FirstOrDefault(); if (firstImpl != null) { return(TypeSystemIdentifiers.GetMemberIdentifier(member.Name, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier))); } } else { var structProp = member as IIntermediateStructPropertyMember; if (structProp != null) { var firstImpl = structProp.Implementations.FirstOrDefault(); if (firstImpl != null) { return(TypeSystemIdentifiers.GetMemberIdentifier(member.Name, string.Format("{0}{1}", firstImpl.FullName, member.UserSpecificQualifier))); } } } } return(IntermediateGateway.DefaultUniqueIdentifierService.GetIdentifier(member)); }
private static void Test <TLanguage, TProvider>(ILanguageProvider <TLanguage, TProvider> provider) where TLanguage : ILanguage <TLanguage, TProvider> where TProvider : ILanguageProvider <TLanguage, TProvider> { IIntermediateAssembly iia = (IIntermediateAssembly)provider.CreateAssembly("TestAssembly"); var idm = iia.IdentityManager; var ienumerableType = (IInterfaceType)idm.ObtainTypeReference(TypeSystemIdentifiers.GetTypeIdentifier("System.Collections.Generic", "IEnumerable", 1)); var structuralExampleMethod = iia.Methods.Add("StructuralExample"); var tdataset = structuralExampleMethod.TypeParameters.Add("TDataset"); var tdatabase = structuralExampleMethod.TypeParameters.Add("TDatabase"); var byteRef = idm.ObtainTypeReference(idm.RuntimeEnvironment.Byte); var datasetIndex = tdataset.Indexers.Add(byteRef, new TypedNameSeries(new TypedName("index", idm.ObtainTypeReference(idm.RuntimeEnvironment.Int32))), true, true); var database = tdataset.Properties.Add(new TypedName("Database", tdatabase), true, false); var dataCopy = tdataset.Methods.Add(new TypedName("GetDataCopy", byteRef.MakeArray())); var clone = tdataset.Methods.Add(new TypedName("Clone", tdataset)); var ctor = tdataset.Constructors.Add(new TypedName("uInst", tdatabase), new TypedName("data", byteRef.MakeArray())); var d = datasetIndex.GetMethod.GetReference(new SpecialReferenceExpression(SpecialReferenceKind.This)).Invoke(); var gvm = datasetIndex.GetMethod.UniqueIdentifier; var parameters = datasetIndex.Parameters; var nextParameter = parameters.Add(new TypedName("testIndex", idm.ObtainTypeReference(RuntimeCoreType.Int16))); var valueParameter = datasetIndex.SetMethod.ValueParameter; nextParameter.ParameterType = idm.ObtainTypeReference(RuntimeCoreType.SByte); iia.Dispose(); }
internal static IGeneralSignatureMemberUniqueIdentifier GetIndexerIdentifier(ICliMetadataPropertyTableRow indexerDef, IType owner, _ICliManager manager) { ICliMetadataMethodDefinitionTableRow targetMethod = null; bool knockOffLast = false; var getMethod = targetMethod = indexerDef.GetMethod; if (getMethod == null) { targetMethod = indexerDef.SetMethod; if (targetMethod == null) { var semanticMethod = indexerDef.Methods.FirstOrDefault(); if (semanticMethod != null) { targetMethod = semanticMethod.Method; } } else { knockOffLast = true; } } if (targetMethod != null) { return(TypeSystemIdentifiers.GetSignatureIdentifier(indexerDef.Name, (from p in (knockOffLast ? targetMethod.Signature.Parameters.Take(targetMethod.Signature.Parameters.Count - 1) : targetMethod.Signature.Parameters) select manager.ObtainTypeReference(p.ParameterType, owner, null, owner == null ? null : owner.Assembly)).SinglePass())); } else { return(TypeSystemIdentifiers.GetSignatureIdentifier(indexerDef.Name)); } }
protected override IntermediateParameterMemberDictionary <IStructMethodMember, IIntermediateStructMethodMember, IMethodParameterMember <IStructMethodMember, IStructType>, IIntermediateMethodParameterMember <IStructMethodMember, IIntermediateStructMethodMember, IStructType, IIntermediateStructType> > InitializeParameters() { var result = base.InitializeParameters(); result._Add(TypeSystemIdentifiers.GetMemberIdentifier("value"), this.valueParameter = new _ValueParameter(this)); return(result); }
internal static IGeneralMemberUniqueIdentifier GetTypeCoercionOperatorIdentifier(ICliMetadataMethodDefinitionTableRow methodDef, IType owner, _ICliManager manager) { var coercionParameter = methodDef.Signature.Parameters.FirstOrDefault(); if (coercionParameter == null) { return(null); } var coercionType = manager.ObtainTypeReference(coercionParameter.ParameterType, owner, null, owner == null ? null : owner.Assembly); var returnType = manager.ObtainTypeReference(methodDef.Signature.ReturnType, owner, null, owner == null ? null : owner.Assembly); if (coercionType == null || returnType == null) { return(null); } var genericOwner = owner as IGenericType; TypeConversionRequirement requirement = (methodDef.Name == CliCommon.TypeCoercionNames.Implicit) ? TypeConversionRequirement.Implicit : (methodDef.Name == CliCommon.TypeCoercionNames.Explicit) ? TypeConversionRequirement.Explicit : TypeConversionRequirement.Unknown; if (genericOwner == null) { goto nonGenericResolution; } else { if (owner.IsGenericConstruct) { if (TypesAreEquivalent(owner, coercionType)) { return(TypeSystemIdentifiers.GetTypeOperatorFromIdentifier(requirement, returnType)); } else if (TypesAreEquivalent(owner, returnType)) { return(TypeSystemIdentifiers.GetTypeOperatorToIdentifier(requirement, coercionType)); } else { goto nonGenericResolution; } } else { goto nonGenericResolution; } } nonGenericResolution: if (owner == coercionType) { return(TypeSystemIdentifiers.GetTypeOperatorFromIdentifier(requirement, returnType)); } else if (owner == returnType) { return(TypeSystemIdentifiers.GetTypeOperatorToIdentifier(requirement, coercionType)); } else { return(null); } }
protected override IntermediateParameterMemberDictionary <IClassMethodMember, IIntermediateClassMethodMember, IMethodParameterMember <IClassMethodMember, IClassType>, IIntermediateMethodParameterMember <IClassMethodMember, IIntermediateClassMethodMember, IClassType, IIntermediateClassType> > InitializeParameters() { var result = base.InitializeParameters(); result.Unlock(); result._Add(TypeSystemIdentifiers.GetMemberIdentifier("value"), this.valueParameter = GetValueParameter()); result.Lock(); return(result); }
protected override bool IsSubclassOfImpl(IType other) { return(this.IdentityManager.ObtainTypeReference(RuntimeCoreType.RootType).Equals(other) #if TYPESYSTEM_CLI || this.IdentityManager.ObtainTypeReference(TypeSystemIdentifiers.GetTypeIdentifier("System", "Delegate", 0)).Equals(other) || this.IdentityManager.ObtainTypeReference(TypeSystemIdentifiers.GetTypeIdentifier("System", "MulticastDelegate", 0)).Equals(other)); #else ; #endif }
public INamespaceDeclaration this[string path] { get { string ns = path; int lastIndex = 0; CliNamespaceKeyedTree topLevel = this.info; INamespaceDictionary topNamespaceDict = this; StringBuilder pathBuilder = new StringBuilder(); bool first = true; nextPart: int next = ns.IndexOf('.', lastIndex); if (first) { first = false; } else { pathBuilder.Append('.'); } if (next != -1) { string current = ns.Substring(lastIndex, next - lastIndex); pathBuilder.Append(current); uint currentHash = (uint)current.GetHashCode(); if (topLevel.ContainsKey(currentHash)) { topLevel = topLevel[currentHash]; topNamespaceDict = topNamespaceDict[TypeSystemIdentifiers.GetDeclarationIdentifier(pathBuilder.ToString())].Namespaces; } else { return(null); } lastIndex = next + 1; goto nextPart; } else { string current = ns.Substring(lastIndex); pathBuilder.Append(current); uint currentHash = (uint)current.GetHashCode(); if (topLevel.ContainsKey(currentHash)) { topLevel = topLevel[currentHash]; return(topNamespaceDict[TypeSystemIdentifiers.GetDeclarationIdentifier(pathBuilder.ToString())]); } else { return(null); } } } }
public IGenericParameterUniqueIdentifier GetIdentifier(IIntermediateGenericParameter member) { if (member.Position > -1) { return(TypeSystemIdentifiers.GetGenericParameterIdentifier(member.Position, member.Name, member is IGenericTypeParameter)); } else { return(TypeSystemIdentifiers.GetGenericParameterIdentifier(member.Name, member is IGenericTypeParameter)); } }
protected override IGeneralDeclarationUniqueIdentifier GetIdentifierFrom(int index, uint metadata) { var namespaceInfo = this.info[metadata]; string fullSpace = namespaceInfo.StringsSection[namespaceInfo.Value]; if (namespaceInfo.SubspaceLength != 0) { fullSpace = fullSpace.Substring(0, namespaceInfo.SubspaceStart + namespaceInfo.SubspaceLength); } return(TypeSystemIdentifiers.GetDeclarationIdentifier(fullSpace)); }
protected override IGeneralGenericTypeUniqueIdentifier OnGetUniqueIdentifier() { if (this.uniqueIdentifier == null) { int typeParamCount; lock (this.SyncObject) typeParamCount = this.typeParameters == null ? 0 : this.typeParameters.Count; this.uniqueIdentifier = TypeSystemIdentifiers.GetTypeIdentifier(this.NamespaceName, this.Name, typeParamCount); } return(this.uniqueIdentifier); }
/// <summary> /// Inserts a series of new <see cref="ITypedLocalMember"/> instances /// with the <see cref="TypedNameSeries"/>, relative to the active /// scope, for the <see cref="ITypedLocalMember"/> elements to add. /// </summary> /// <param name="namesAndTypes">The <see cref="TypedNameSeries"/> /// which denotes each element's name and type within the active scope.</param> /// <returns>a series of new <see cref="ITypedLocalMember"/> instances /// with the <see cref="TypedNameSeries"/> provided.</returns> public ITypedLocalMember[] AddRange(TypedNameSeries namesAndTypes) { var seriesElements = namesAndTypes.ToArray(); Stack <ILocalMemberDictionary> memberScopes = GetFullScope(); IGeneralMemberUniqueIdentifier[] ids = new IGeneralMemberUniqueIdentifier[namesAndTypes.Count]; for (int i = 0; i < seriesElements.Length; i++) { ids[i] = TypeSystemIdentifiers.GetMemberIdentifier(seriesElements[i].Name); } for (int i = 0; i < seriesElements.Length; i++) { var iElementIdentifier = ids[i]; /* * * First check for name collisions within the series itself. * */ for (int j = i + 1; j < seriesElements.Length; j++) { if (iElementIdentifier.Equals(ids[j])) { throw new ArgumentException("Duplicate name detected"); } } /* * * Next, check for collisions within the scope. * */ foreach (var scope in memberScopes) { if (scope.ContainsKey(iElementIdentifier)) { throw new ArgumentException("Duplicate name detected"); } } } var parentMember = this.GetTopParent() as IIntermediateMember; ITypedLocalMember[] locals = new ITypedLocalMember[seriesElements.Length]; for (int i = 0; i < seriesElements.Length; i++) //Parallel.For(0, seriesElements.Length, i => { var current = seriesElements[i]; var localType = current.GetTypeRef(); if (localType.ContainsSymbols()) { localType = localType.SimpleSymbolDisambiguation(parentMember); } locals[i] = new TypedLocalMember(current.Name, this.Parent, localType); }//**/); this._AddRange(from local in locals select new KeyValuePair <IGeneralMemberUniqueIdentifier, ILocalMember>(local.UniqueIdentifier, local)); return(locals); }
public bool ContainsKey(string key) { if (key == null) { throw new ArgumentNullException("key"); } if (key == string.Empty) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.key, ExceptionMessageId.ArgumentCannotBeEmpty, ThrowHelper.GetArgumentName(ArgumentWithException.key)); } return(this.ContainsKey(TypeSystemIdentifiers.GetDeclarationIdentifier(key))); }
internal static IClassPropertyMember GetProperty(this IClassType top, string name) { var muid = TypeSystemIdentifiers.GetMemberIdentifier(name); for (IClassType current = top; current != null; current = current.BaseType) { if (current.Properties.ContainsKey(muid)) { return(current.Properties[muid]); } } throw new InvalidOperationException(string.Format("No property {0} found.", name)); }
public GenericParameterDictionary(SymbolType parent, string[] tParamNames) : this(parent) { if (tParamNames != null) { this.tParamNames = new IGenericParameterUniqueIdentifier[tParamNames.Length]; for (int i = 0; i < tParamNames.Length; i++) { this.tParamNames[i] = TypeSystemIdentifiers.GetGenericParameterIdentifier(i, true); } this.elements = new GenericParameterMember[tParamNames.Length]; } }
internal static IGeneralGenericSignatureMemberUniqueIdentifier GetMethodIdentifier(ICliMetadataMethodDefinitionTableRow methodDef, IType owner, _ICliManager manager, Func <IMethodSignatureMember> memberGetter) { bool typeParamCheck = methodDef.MetadataRoot.TableStream.GenericParameterTable != null; if (typeParamCheck) { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(methodDef.Name, methodDef.TypeParameters.Count, (from p in methodDef.Signature.Parameters select manager.ObtainTypeReference(p.ParameterType, owner, memberGetter(), owner == null ? null : owner.Assembly)).SinglePass())); } else { return(TypeSystemIdentifiers.GetGenericSignatureIdentifier(methodDef.Name, 0, (from p in methodDef.Signature.Parameters select manager.ObtainTypeReference(p.ParameterType, owner, memberGetter(), owner == null ? null : owner.Assembly)).SinglePass())); } }
protected override IGenericParameterUniqueIdentifier OnGetUniqueIdentifier() { if (this.uniqueIdentifier == null) { if (this.Position > -1) { this.uniqueIdentifier = TypeSystemIdentifiers.GetGenericParameterIdentifier(this.Position, this.Name, true); } else { this.uniqueIdentifier = TypeSystemIdentifiers.GetGenericParameterIdentifier(this.Name, true); } } return(this.uniqueIdentifier); }
protected override IGeneralTypeUniqueIdentifier OnGetUniqueIdentifier() { lock (this.SyncObject) if (this.uniqueIdentifier == null) { if (this.Parent is IType) { this.uniqueIdentifier = ((IType)this.Parent).UniqueIdentifier.GetNestedIdentifier(this.Name, 0); } else if (this.Parent is INamespaceDeclaration) { this.uniqueIdentifier = TypeSystemIdentifiers.GetTypeIdentifier(((INamespaceDeclaration)this.Parent).FullName, this.Name, 0); } else { this.uniqueIdentifier = TypeSystemIdentifiers.GetTypeIdentifier((IGeneralDeclarationUniqueIdentifier)null, this.Name, 0); } } return(this.uniqueIdentifier); }
public Tuple <IIntermediateInterfaceType, IIntermediateClassType> Build(Tuple <ParserCompiler, CommonSymbolBuilder, IIntermediateAssembly> input) { this.assembly = input.Item3; this.compiler = input.Item1; this.commonSymbolBuilder = input.Item2; var resultInterface = assembly.DefaultNamespace.Parts.Add().Interfaces.Add("I{0}SymbolStream", this.compiler.Source.Options.AssemblyName); var iFaceTParam = resultInterface.TypeParameters.Add(new GenericParameterData("TSymbol", new IType[] { input.Item2.ILanguageSymbol })); var resultClass = assembly.DefaultNamespace.Parts.Add().Classes.Add("{0}SymbolStream", this.compiler.Source.Options.AssemblyName); var classTParam = resultClass.TypeParameters.Add(new GenericParameterData("TSymbol", new IType[] { input.Item2.ILanguageSymbol })); resultClass.ImplementedInterfaces.ImplementInterfaceQuick(resultInterface.MakeGenericClosure(classTParam)); var readOnlyList = typeof(IReadOnlyList <>).ObtainCILibraryType <IInterfaceType>(assembly.IdentityManager).MakeGenericClosure(iFaceTParam); resultInterface.ImplementedInterfaces.Add(readOnlyList); var initialIndexer = readOnlyList.Indexers[0].Value; var readOnlyCollection = (IInterfaceType)readOnlyList.ImplementedInterfaces[0]; EndOFilePresent = resultInterface.Properties.Add(new TypedName("EndOFilePresent", RuntimeCoreType.Boolean, assembly.IdentityManager), true, false); EndOFilePresent.SummaryText = string.Format(@"Returns whether the @s:{0}Symbols.{1}; is present within the @s:{2}{{TSymbol}};", this.compiler.Source.Options.AssemblyName, this.compiler.LexicalSymbolModel.GetEofIdentityField().Name, resultInterface.Name); var countProp = readOnlyCollection.Properties[TypeSystemIdentifiers.GetMemberIdentifier("Count")]; CreateInternalStream(resultClass, classTParam); CreateInternalStreamImpl(resultClass, classTParam); this.CreateCountImpl(resultClass, countProp); CreateEndOfFilePresentImpl(resultClass, initialIndexer, readOnlyCollection, this.CountImpl); CreateIndexerImpl(resultClass, initialIndexer); var enumeratorTypeOfT = typeof(IEnumerator <>).ObtainCILibraryType <IInterfaceType>(assembly.IdentityManager).MakeGenericClosure(classTParam); var enumeratorType = typeof(IEnumerator).ObtainCILibraryType <IInterfaceType>(assembly.IdentityManager); var enumerableType = typeof(IEnumerable).ObtainCILibraryType <IInterfaceType>(assembly.IdentityManager); this.CreateGetEnumerator(resultClass, enumeratorTypeOfT, enumeratorType, enumerableType); this.ResultInterface = resultInterface; this.ResultClass = resultClass; this.InternalStream.AccessLevel = AccessLevelModifiers.Private; this.EndOFilePresentImpl.AccessLevel = AccessLevelModifiers.Public; this.ResultInterface.AccessLevel = AccessLevelModifiers.Public; this.ResultClass.AccessLevel = AccessLevelModifiers.Internal; return(Tuple.Create(this.ResultInterface, this.ResultClass)); }
public static IAssemblyUniqueIdentifier GetVersionedMicrosoftVisualBasicLibrary(VisualBasicVersion languageVersion = VisualBasicVersion.CurrentVersion) { switch (languageVersion) { case VisualBasicVersion.Version07: return(TypeSystemIdentifiers.GetAssemblyIdentifier(microsoftVisualBasicLibName, vbV7, CultureIdentifiers.None, MicrosoftLanguageVendor.stdLibPublicKeyToken)); case VisualBasicVersion.Version07_1: return(TypeSystemIdentifiers.GetAssemblyIdentifier(microsoftVisualBasicLibName, vbV7_1, CultureIdentifiers.None, MicrosoftLanguageVendor.stdLibPublicKeyToken)); case VisualBasicVersion.Version08: case VisualBasicVersion.Version09: return(TypeSystemIdentifiers.GetAssemblyIdentifier(microsoftVisualBasicLibName, vbV8, CultureIdentifiers.None, MicrosoftLanguageVendor.stdLibPublicKeyToken)); case VisualBasicVersion.Version10: case VisualBasicVersion.Version11: case VisualBasicVersion.Version12: return(TypeSystemIdentifiers.GetAssemblyIdentifier(microsoftVisualBasicLibName, vbV10, CultureIdentifiers.None, MicrosoftLanguageVendor.stdLibPublicKeyToken)); default: goto case VisualBasicVersion.CurrentVersion; } }
public FieldMember(IStructType parent, ICliMetadataFieldTableRow metadataEntry) : base(parent, metadataEntry, TypeSystemIdentifiers.GetMemberIdentifier(metadataEntry.Name)) { }
public TIntermediateGenericParameter[] AddRange(params GenericParameterData[] genericParameterData) { if (this.Locked) { throw new InvalidOperationException(Resources.ObjectStateThrowMessage); } if (genericParameterData == null) { throw new ArgumentNullException("genericParameterData"); } TIntermediateGenericParameter[] result = new TIntermediateGenericParameter[genericParameterData.Length]; IGenericParameterUniqueIdentifier[] currentKeys = new IGenericParameterUniqueIdentifier[result.Length]; //Parallel.For(0, genericParameterData.Length, i => for (int i = 0; i < genericParameterData.Length; i++) { var currentName = genericParameterData[i].Name; var current = this.GetNew(currentName); var currentUniqueId = TypeSystemIdentifiers.GetGenericParameterIdentifier(i + this.Count, currentName, Parent is IType); if (this.ContainsKey(currentUniqueId) || currentKeys.Contains(currentUniqueId)) { throw new ArgumentException("genericParameterData"); } currentKeys[i] = currentUniqueId; result[i] = current; }//**/); this._AddRange((from i in 0.RangeTo(genericParameterData.Length) select new KeyValuePair <IGenericParameterUniqueIdentifier, TGenericParameter>(currentKeys[i], result[i]))); //Parallel.For(0, genericParameterData.Length, i=> for (int i = 0; i < genericParameterData.Length; i++) { var currentParameterData = genericParameterData[i]; var current = result[i]; foreach (var constraint in currentParameterData.Constraints) { current.Constraints.Add(TransposeType(constraint, current)); } foreach (var ctorSig in currentParameterData.Constructors.Signatures) { current.Constructors.Add(TransposeTypedNames(ctorSig.Parameters.ToSeries(), current)); } foreach (var eventGroup in TransposeTypedNames(currentParameterData.Events, current)) { current.Events.Add(eventGroup); } foreach (var indexerSig in currentParameterData.Indexers.Signatures) { current.Indexers.Add(TransposeTypedName(new TypedName(indexerSig.Name, indexerSig.ReturnType), current), TransposeTypedNames(indexerSig.Parameters.ToSeries(), current)); } //result.Properties.Add current.SpecialConstraint = currentParameterData.SpecialConstraint; foreach (var method in currentParameterData.Methods.Signatures) { current.Methods.Add(TransposeTypedName(new TypedName(method.Name, method.ReturnType), current), TransposeTypedNames(method.Parameters.ToSeries(), current)); } }//*/); //Parallel.For(0, genericParameterData.Length, i => //for (int i = 0; i < genericParameterData.Length; i++) //{ // var currentParameterData = genericParameterData[i]; // var current = result[i]; // foreach (var constraint in currentParameterData.Constraints) // if (constraint.ContainsSymbols()) // current.Constraints.Add(constraint.SimpleSymbolDisambiguation(current)); // else // current.Constraints.Add(constraint); // foreach (var ctor in current.Constructors.Values) // foreach (var param in ctor.Parameters.Values) // if (param.ParameterType.ContainsSymbols()) // param.ParameterType = param.ParameterType.SimpleSymbolDisambiguation(current); // foreach (var method in current.Methods.Values) // { // foreach (var param in method.Parameters.Values) // if (param.ParameterType.ContainsSymbols()) // param.ParameterType = param.ParameterType.SimpleSymbolDisambiguation(current); // if (method.ReturnType.ContainsSymbols()) // method.ReturnType = method.ReturnType.SimpleSymbolDisambiguation(current); // } // foreach (var property in current.Properties.Values) // if (property.PropertyType.ContainsSymbols()) // property.PropertyType = property.PropertyType.SimpleSymbolDisambiguation(current); // foreach (var indexer in current.Indexers.Values) // { // if (indexer.PropertyType.ContainsSymbols()) // indexer.PropertyType = indexer.PropertyType.SimpleSymbolDisambiguation(current); // foreach (var param in indexer.Parameters.Values) // if (param.ParameterType.ContainsSymbols()) // param.ParameterType = param.ParameterType.SimpleSymbolDisambiguation(current); // } //}//); return(result); }
public TIntermediateGenericParameter Add(GenericParameterData genericParameterData) { if (this.Locked) { throw new InvalidOperationException(Resources.ObjectStateThrowMessage); } if (string.IsNullOrEmpty(genericParameterData.Name)) { throw new ArgumentException("genericParameterData"); } int index = this.Count; var defaultParamId = TypeSystemIdentifiers.GetGenericParameterIdentifier(index, this.Parent is IType); var result = this.GetNew(genericParameterData.Name); if (this.ContainsKey(defaultParamId)) { throw new ArgumentException("genericParameterData"); } foreach (var ctorSig in genericParameterData.Constructors.Signatures) { result.Constructors.Add(TransposeTypedNames(ctorSig.Parameters.ToSeries(), result)); } var disambiguatedEvents = TransposeTypedNames(genericParameterData.Events, result); foreach (var eventGroup in disambiguatedEvents) { result.Events.Add(eventGroup); } IControlledTypeCollection typeParameters = null; IControlledTypeCollection methodTypeParameters = null; foreach (var constraint in genericParameterData.Constraints) { if (constraint.ContainsSymbols()) { if (constraint.ContainsGenericParameters()) { result.Constraints.Add(Disambiguate(constraint).SimpleSymbolDisambiguation(result)); } else { result.Constraints.Add(constraint.SimpleSymbolDisambiguation(result)); } } else if (constraint.ContainsGenericParameters()) { result.Constraints.Add(Disambiguate(constraint)); } else { result.Constraints.Add(constraint); } } result.SpecialConstraint = genericParameterData.SpecialConstraint; //foreach (var propertyGroup in genericParameterData.Properties) //result.Properties.Add foreach (var method in genericParameterData.Methods.Signatures) { result.Methods.Add(new TypedName(method.Name, method.ReturnType), method.Parameters.ToSeries()); } this._Add(defaultParamId, result); this.Keys[index] = result.UniqueIdentifier; return(result); }