/// <summary> /// Adds a new <typeparamref name="TIntermediateIndexer"/> with /// the <paramref name="nameAndReturn"/> and /// <paramref name="parameters"/> provided. /// </summary> /// <param name="nameAndReturn">The <see cref="TypedName"/> /// which specifies the indexer name and return type.</param> /// <param name="parameters">The <see cref="TypedNameSeries"/> /// which denotes the types and names of the parameters of the /// indexer to add.</param> /// <param name="canGet">Whether the property can be read.</param> /// <param name="canSet">Whether the property can be written.</param> /// <returns>A <typeparamref name="TIntermediateIndexer"/> which /// represents the indexer added.</returns> /// <exception cref="System.ArgumentException">thrown another /// member within the <see cref="IIntermediateIndexerMemberDictionary"/> /// contains the same signature.</exception> public TIntermediateIndexer Add(TypedName nameAndReturn, TypedNameSeries parameters, bool canGet = true, bool canSet = true) { var result = this.GetNew(nameAndReturn, parameters, canGet, canSet); base._Add(result.UniqueIdentifier, result); return(result); }
/// <summary> /// Adds a <typeparamref name="TIntermediateEvent"/> with the <paramref name="name"/> and /// <paramref name="eventSignature"/> provided. /// </summary> /// <param name="name">The <see cref="String"/> name of the event.</param> /// <param name="eventSignature">The <see cref="TypedNameSeries"/> that designates /// the names and types of the parameters of a delegate signature that will be /// generated upon translation.</param> /// <returns>A <typeparamref name="TIntermediateEvent"/> instance.</returns> public TIntermediateEvent Add(string name, TypedNameSeries eventSignature) { var result = this.GetEvent(name, eventSignature); this.AddDeclaration(result); return(result); }
/// <summary> /// Adds a new <typeparamref name="TIntermediateSignature"/> with the /// <paramref name="name"/>, <paramref name="parameters"/>, and /// <paramref name="typeParameters"/>provided. /// </summary> /// <param name="name">The <see cref="String"/> representing the name the method is referred to by.</param> /// <param name="parameters">The <see cref="TypedNameSeries"/> which designates /// the parameter names and types of the new <typeparamref name="TIntermediateSignature"/>.</param> /// <param name="typeParameters">An array of <see cref="GenericParameterData"/> which /// defines the type-parameters and their individual type and functional constraints.</param> /// <returns>A new <typeparamref name="TIntermediateSignature"/> /// which has a <see cref="System.Void"/> return-type.</returns> /// <exception cref="System.ArgumentNullException">thrown when <paramref name="name"/> is null, or <paramref name="typeParameters"/> /// is null.</exception> /// <exception cref="System.ArgumentException">thrown when <paramref name="name"/> is <see cref="String.Empty"/> /// or an element of <paramref name="parameters"/>, or <paramref name="typeParameters"/> contains an invalid type-reference (<see cref="System.Void"/>).</exception> public TIntermediateSignature Add(string name, TypedNameSeries parameters, params GenericParameterData[] typeParameters) { var method = this.GetNewMethodWithParametersAndTypeParameters(name, parameters, typeParameters); method.ReturnType = this.identityManager.ObtainTypeReference(RuntimeCoreType.VoidType); this.AddDeclaration(method); return(method); }
/// <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); }
/// <summary> /// Adds a <typeparamref name="TIntermediateCtor"/> /// with the <paramref name="parameters"/> provided. /// </summary> /// <param name="parameters">The <see cref="TypedNameSeries"/> /// which identifies all of the parameters by name and type.</param> /// <returns>A <typeparamref name="TIntermediateCtor"/> instance with /// the <paramref name="parameters"/> specified.</returns> /// <exception cref="System.ArgumentException">The provided set of <paramref name="parameters"/> /// exists already, or a name of one of the parameters is null.</exception> public new TIntermediateCtor Add(TypedNameSeries parameters) { TIntermediateCtor item = this.GetConstructor(); item.Parameters.AddRange(parameters.ToArray()); if (this.ContainsKey(item.UniqueIdentifier)) { throw new ArgumentException("parameters"); } this.AddDeclaration(item); return(item); }
protected override TIntermediateIndexer GetNew(TypedName nameAndReturn, TypedNameSeries parameters, bool canGet = true, bool canSet = true) { var result = (TIntermediateIndexer)(object)this.Parent.GetNewIndexer(nameAndReturn); if (parameters.Count > 0) { result.Parameters.AddRange(parameters.ToArray()); } result.CanRead = canGet; result.CanWrite = canSet; return(result); }
/// <summary> /// Adds a new <typeparamref name="TIntermediateSignature"/> /// instane with the <paramref name="parameters"/>, <paramref name="typeParameters"/>, <paramref name="nameAndReturn"/> /// provided. /// </summary> /// <param name="nameAndReturn">A <see cref="TypedName"/> which designates the name of the method and its /// return-type.</param> /// <param name="parameters">The <see cref="TypedNameSeries"/> which designates /// the parameter names and types of the new <typeparamref name="TIntermediateSignature"/>.</param> /// <param name="typeParameters">An array of <see cref="GenericParameterData"/> which /// defines the type-parameters and their individual type and functional constraints.</param> /// <returns>A new <typeparamref name="TIntermediateSignature"/>.</returns> /// <exception cref="System.ArgumentException">thrown when the name portion of <paramref name="nameAndReturn"/> is <see cref="String.Empty"/> /// or an element of <paramref name="parameters"/>, or <paramref name="typeParameters"/> contains an invalid type-reference (<see cref="System.Void"/>).</exception> /// <exception cref="System.ArgumentNullException">thrown when <paramref name="typeParameters"/> /// is null.</exception> public TIntermediateSignature Add(TypedName nameAndReturn, TypedNameSeries parameters, params GenericParameterData[] typeParameters) { TIntermediateSignature method = this.Add(nameAndReturn.Name, parameters, typeParameters); var returnType = nameAndReturn.GetTypeRef(); if (returnType.ContainsSymbols()) { method.ReturnType = returnType.SimpleSymbolDisambiguation(method); } else { method.ReturnType = returnType; } return(method); }
/// <summary> /// Adds a new <typeparamref name="TIntermediateSignature"/> /// instance with the <paramref name="parameters"/>, <paramref name="nameAndReturn"/> provided. /// </summary> /// <param name="nameAndReturn">A <see cref="TypedName"/> which designates the name of the method and its /// return-type.</param> /// <param name="parameters">The <see cref="TypedNameSeries"/> which designates /// the parameter names and types of the new <typeparamref name="TIntermediateSignature"/>.</param> /// <returns>A new <typeparamref name="TIntermediateSignature"/>.</returns> /// <exception cref="System.ArgumentException">thrown when the name portion of <paramref name="nameAndReturn"/> is <see cref="String.Empty"/> /// or an element of <paramref name="parameters"/> contains an invalid type-reference (<see cref="System.Void"/>).</exception> public TIntermediateSignature Add(TypedName nameAndReturn, TypedNameSeries parameters) { var method = this.GetNewMethodWithParameters(nameAndReturn.Name, parameters); //TIntermediateSignature method = this.Add(nameAndReturn.Name, parameters); var returnType = nameAndReturn.GetTypeRef(); if (returnType.ContainsSymbols()) { method.ReturnType = returnType.SimpleSymbolDisambiguation(method); } else { method.ReturnType = returnType; } this.AddDeclaration(method); return(method); }
IIntermediateConstructorMember IIntermediateConstructorMemberDictionary.Add(TypedNameSeries parameters) { return(this.Add(parameters)); }
/// <summary> /// Adds a new <typeparamref name="TIntermediateIndexer"/> with /// the <paramref name="returnType"/> and /// <paramref name="parameters"/> provided. /// </summary> /// <param name="returnType">The <see cref="IType"/> which /// results from the indexer operation.</param> /// <param name="parameters">The <see cref="TypedNameSeries"/> /// which denotes the types and names of the parameters of the /// indexer to add.</param> /// <param name="canGet">Whether the property can be read.</param> /// <param name="canSet">Whether the property can be written.</param> /// <returns>A <typeparamref name="TIntermediateIndexer"/> which /// represents the indexer added.</returns> /// <exception cref="System.ArgumentException">thrown another /// member within the <see cref="IIntermediateIndexerMemberDictionary"/> /// contains the same signature.</exception> public TIntermediateIndexer Add(IType returnType, TypedNameSeries parameters, bool canGet = true, bool canSet = true) { return(this.Add(new TypedName(null, returnType), parameters, canGet, canSet)); }
IIntermediateIndexerMember IIntermediateIndexerMemberDictionary.Add(TypedName nameAndReturn, TypedNameSeries parameters, bool canGet, bool canSet) { return(this.Add(nameAndReturn, parameters, canGet, canSet)); }
IIntermediateIndexerMember IIntermediateIndexerMemberDictionary.Add(IType returnType, TypedNameSeries parameters, bool canGet, bool canSet) { return(this.Add(returnType, parameters, canGet, canSet)); }
protected abstract TIntermediateIndexer GetNew(TypedName nameAndReturn, TypedNameSeries parameters, bool canGet, bool canSet);
/* * * Lovely method name, huh? * */ private TIntermediateSignature GetNewMethodWithParametersAndTypeParameters(string name, TypedNameSeries parameters, GenericParameterData[] typeParameters) { var method = this.GetNewMethod(name); if (typeParameters.Length > 0) { method.TypeParameters.AddRange(typeParameters); } if (parameters.Count > 0) { var internalParameters = method.Parameters as IntermediateParameterMemberDictionary <TSignature, TIntermediateSignature, TSignatureParameter, TIntermediateSignatureParameter>; if (parameters != null) { /* Method hasn't been added yet, processing the event requests would be an effort in futility. */ internalParameters.SkipEvents = true; internalParameters.AddRange(parameters.ToArray()); internalParameters.SkipEvents = false; } else { method.Parameters.AddRange(parameters.ToArray()); } } return(method); }
public void BuildVisitor() { var nameWithoutTail = string.Join("", this.NameParts.Take(this.NameParts.Length - 1)).LowerFirstCharacter(); var namePartsWithoutTail = this.NameParts.Take(this.NameParts.Length - 1).Select(k => k.ToLower()).ToArray(); var lastItem = namePartsWithoutTail.Last(); if (lastItem == "code") #pragma warning disable 642 { ;//Do nothing, keep it the same. } #pragma warning restore 642 else if (lastItem.EndsWith("y")) { namePartsWithoutTail[namePartsWithoutTail.Length - 1] = lastItem.Substring(0, lastItem.Length - 1) + "ies"; } else if (!lastItem.EndsWith("s")) { namePartsWithoutTail[namePartsWithoutTail.Length - 1] = lastItem + "s"; } IGenericTypeParameter <IGeneralGenericTypeUniqueIdentifier, IInterfaceType> tResult; IGenericTypeParameter <IGeneralGenericTypeUniqueIdentifier, IInterfaceType> tContext; this.VisitorInterface.TypeParameters.TryGetValue(TypeSystemIdentifiers.GetGenericParameterIdentifier("TResult"), out tResult); this.VisitorInterface.TypeParameters.TryGetValue(TypeSystemIdentifiers.GetGenericParameterIdentifier("TContext"), out tContext); this.VisitorInterface.SummaryText = string.Format("Represents a basic visitor for {2}{0}{1}.", tResult != null ? " which yields a result of @t:TResult;" : string.Empty, tContext != null ? string.Format("{0} has a @t:TContext; relevant to the visit", tResult != null ? " and also" : " which") : string.Empty, string.Join(" ", namePartsWithoutTail)); if (tResult != null) { ((IIntermediateGenericTypeParameter <IGeneralGenericTypeUniqueIdentifier, IInterfaceType, IIntermediateInterfaceType>)(tResult)).SummaryText = string.Format("Denotes the type of result the members of the @s:{0}; should yield.", this.VisitorInterface.MakeGenericClosure(this.VisitorInterface.GenericParameters).BuildTypeName(true, typeParameterDisplayMode: TypeParameterDisplayMode.CommentStandard)); } if (tContext != null) { ((IIntermediateGenericTypeParameter <IGeneralGenericTypeUniqueIdentifier, IInterfaceType, IIntermediateInterfaceType>)(tContext)).SummaryText = string.Format("Denotes the type of context the members of the @s:{0}; should receive along with the types that accept the visitor.", this.VisitorInterface.MakeGenericClosure(this.VisitorInterface.GenericParameters).BuildTypeName(true, typeParameterDisplayMode: TypeParameterDisplayMode.CommentStandard)); } IType resultType = tResult ?? this._assembly.IdentityManager.ObtainTypeReference(RuntimeCoreType.VoidType); var methodLookup = new Dictionary <IType, IIntermediateInterfaceMethodMember>(); /* Skipped types are for the notion of inheritance-based visitors which are derived from multiple other visitors, we skip the types associated to those inherited visitors to avoid repeating their signatures. */ foreach (var type in this.RelevantTypes.Except(this.SkippedTypes).OrderBy(k => k.FullName)) { var gpData = new List <GenericParameterData>(); if (type.IsGenericConstruct) { var genericType = (IGenericType)type; if (genericType.IsGenericDefinition) { foreach (IGenericTypeParameter typeParam in genericType.TypeParameters.Values) { gpData.Add(new GenericParameterData(typeParam.Name, typeParam.Constraints.Select(k => k.TurnTypeParametersIntoSymbols()) /*.Select(constraint=>constraint.IsGenericConstruct ? ((IGenericType)(constraint)).MakeGenericClosure(((IGenericType)(constraint)).GenericParameters) : constraint.IsGenericTypeParameter ? constraint.Name.GetSymbolType() : constraint)*/.ToArray()) { SpecialConstraint = typeParam.SpecialConstraint }); } } } TypedNameSeries paramData = new TypedNameSeries(); paramData.Add(type.WithName(nameWithoutTail)); if (tContext != null) { paramData.Add(tContext.WithName("context")); } var method = this.VisitorInterface.Methods.Add(resultType.WithName("Visit"), paramData, gpData.ToArray()); methodLookup.Add(type, method); if (tContext != null) { var contextParam = method.Parameters["context"]; contextParam.SummaryText = "The @t:TContext; relevant to the visit."; } var inputParam = method.Parameters[nameWithoutTail]; if (tResult != null) { method.SummaryText = string.Format("Returns a @t:{1}; after it visits the @p:{0}; provided{2}.", inputParam.Name, tResult.Name, tContext == null ? string.Empty : " with the given @p:context;"); method.ReturnsText = @"Returns the value of @t:TResult; relative to the implementation of the visitor."; } else { method.SummaryText = string.Format("Visits the @p:{0}; provided{1}.", inputParam.Name, tContext == null ? string.Empty : " with the given @p:context;"); } var commentType = ((IGenericType)(type)); string ofText = string.Empty; if (commentType.IsGenericConstruct && !commentType.IsGenericDefinition && this._detail.TypeParameterVariations != null && this._detail.TypeParameterVariations.Length > 0) { ofText = string.Format(" of @s:{0};", commentType.GenericParameters.First().BuildTypeName()); commentType = (IGenericType)commentType.ElementType; } if (commentType.IsGenericConstruct && commentType.IsGenericDefinition) { commentType = commentType.MakeGenericClosure(commentType.GenericParameters); } inputParam.SummaryText = string.Format("The @s:{0};{1} relevant to the visit.", commentType.BuildTypeName(true, typeParameterDisplayMode: TypeParameterDisplayMode.CommentStandard), ofText); } this.TypeToMethodLookup = methodLookup; }
/// <summary> /// Obtains a <typeparamref name="TIntermediateEvent"/> to fulfill an <see cref="Add(String, TypedNameSeries)"/> /// request. /// </summary> /// <param name="name">The <see cref="String"/> name of the event.</param> /// <param name="eventSignature">The <see cref="TypedNameSeries"/> that designates /// the names and types of the parameters of a delegate signature that will be /// generated upon translation.</param> /// <returns>A <typeparamref name="TIntermediateEvent"/> instance.</returns> protected abstract TIntermediateEvent GetEvent(string name, TypedNameSeries eventSignature);
private TypedNameSeries TransposeTypedNames(TypedNameSeries series, TIntermediateGenericParameter target) { return(new TypedNameSeries((from s in series select TransposeTypedName(s, target)).ToArray())); }
/// <summary> /// Converts the <see cref="TypedNameSeries"/> to a <see cref="SignatureData"/> /// instance. /// </summary> /// <param name="series">The <see cref="TypedNameSeries"/> to convert.</param> /// <returns>A new <see cref="SignatureData"/> instance equivalent to /// <paramref name="series"/>.</returns> public static SignatureData FromTypedNameSeries(TypedNameSeries series) { return(series); }
private TIntermediateSignature GetNewMethodWithParameters(string name, TypedNameSeries parameters) { return(this.GetNewMethodWithParametersAndTypeParameters(name, parameters, GenericParameterData.EmptySet)); }
IIntermediateMethodSignatureMember IIntermediateMethodSignatureMemberDictionary.Add(TypedName nameAndReturn, TypedNameSeries parameters, params GenericParameterData[] typeParameters) { return(this.Add(nameAndReturn, parameters, typeParameters)); }
IIntermediateMethodSignatureMember IIntermediateMethodSignatureMemberDictionary.Add(string name, TypedNameSeries parameters) { return(this.Add(name, parameters)); }
protected override IntermediateClassType <TInstanceIntermediateType> .EventMember GetNewEvent(string name, TypedNameSeries eventSignature) { var result = new EventMember(((TInstanceIntermediateType)(object)this)) { SignatureSource = EventSignatureSource.Declared, Name = name }; foreach (var param in eventSignature) { result.Parameters.Add(param.Name, param.GetTypeRef(), param.Direction); } return(result); }
public void BuildImplementation(IAssembly target) { if (IEnumerableOfT == null) { IEnumerableOfT = typeof(IEnumerable <>).GetTypeReference <IInterfaceType>(this._assembly.IdentityManager); } if (IControlledDictionaryOfTKeyTValue == null) { IControlledDictionaryOfTKeyTValue = typeof(IControlledDictionary <,>).GetTypeReference <IInterfaceType>(this._assembly.IdentityManager); } if (IntermediateDeclDict == null) { IntermediateDeclDict = typeof(IIntermediateDeclarationDictionary <, ,>).GetTypeReference <IInterfaceType>(this._assembly.IdentityManager); } IType ignoreAttr = typeof(VisitorImplementationIgnorePropertyAttribute).GetTypeReference(this._assembly.IdentityManager); IType ignoreSetAttr = typeof(VisitorImplementationIgnoreLocalSetAttribute).GetTypeReference(this._assembly.IdentityManager); var requireAttr = typeof(VisitorPropertyRequirementAttribute).GetTypeReference(this._assembly.IdentityManager); bool visitorsDoNotNeedConstraints = !string.IsNullOrEmpty(this.Detail.VisitRefactorName); var builderInterfaces = this._builders.SelectMany(k => k.RelevantTypes).Distinct().OfType <IInterfaceType>().ToArray(); //var allEnumerables = builderInterfaces.Select(k => CreateEnumerableVariant(k)).ToArray(); var distinctInterfaces = builderInterfaces.Concat(builderInterfaces.SelectMany(k => k.ImplementedInterfaces)).Distinct().ToArray(); var interfaceProperties = (from iFace in distinctInterfaces.OfType <IInterfaceType>() from prop in iFace.Properties.Values /*.Where(k => IsPropertyRelevant(ignoreAttr, builderInterfaces, k))*/.DefaultIfEmpty() group prop by iFace).ToDictionary(k => k.Key, v => (v.First() == null ? (IEnumerable <IInterfacePropertyMember>) new IInterfacePropertyMember[0] : v).ToList()); var interfacesWithAccept = distinctInterfaces.OfType <IInterfaceType>().Where(k => k.Methods.Values.Any(j => j.Name == "Accept")).ToArray(); var actionDetail = typeof(VisitorImplementationActionDetailAttribute).GetTypeReference <IClassType>(this._assembly.IdentityManager); var relevantActionDetail = target.Metadata.Where(k => k.Type == actionDetail && k.Parameters.GetIndexedParameter <string>(0).Item2 == this.Detail.TargetContext); var relevantActionDetailLookup = relevantActionDetail.ToDictionary(k => k.Parameters.GetIndexedParameter <IType>(1).Item2, v => VisitorImplementationActionDetail.DeriveFromMetadata(v)); var relevantActionTypes = relevantActionDetailLookup.Keys.ToArray(); //foreach (var key in relevantActionTypes) // foreach (var @interface in key.ImplementedInterfaces) // if (!relevantActionDetailLookup.ContainsKey(@interface)) // relevantActionDetailLookup.Add(@interface, relevantActionDetailLookup[key]); builderInterfaces = builderInterfaces.Concat(interfacesWithAccept).Distinct().ToArray(); var inheritanceDetail = (from iFace in builderInterfaces let baseTypes = iFace.ImplementedInterfaces.OfType <IInterfaceType>() from iFace2 in new[] { iFace }.Concat(baseTypes).Distinct() group iFace2 by iFace).ToDictionary(k => k.Key, v => v.ToArray()); bool isVoidReturn = !this.Detail.YieldingVisitor; if (visitorsDoNotNeedConstraints) { this.SecondaryResult = this.VisitorResult.Parts.Add(); var relativeRoot = new string[] { this.VisitorResult.NamespaceName, this._assembly.DefaultNamespace.FullName }.GetRelativeRoot("."); if (!string.IsNullOrEmpty(relativeRoot)) { relativeRoot = this.VisitorResult.NamespaceName.Substring(relativeRoot.Length + 1); relativeRoot = relativeRoot.Replace(".", @"\") + @"\"; } this.SecondaryResult.Assembly.FileName = string.Format("{2}{0} ({1} Signatures)", this.Detail.TargetContext, this.Detail.VisitRefactorName, relativeRoot); this.VisitorResult.Assembly.FileName = string.Format("{1}{0} (Visitor Signatures)", this.Detail.TargetContext, relativeRoot); } foreach (var builder in this._builders) { if (this.Detail.InheritedVisitors.Contains(builder.Detail.TargetContext)) { this.VisitorResult.ImplementedInterfaces.ImplementInterfaceQuick(builder.VisitorInterface); } foreach (var method in builder.VisitorInterface.Methods.Values) { var gpData = new GenericParameterData[method.GenericParameters.Count]; if (method.TypeParameters.Count > 0) { for (int i = 0; i < method.TypeParameters.Count; i++) { var gParam = method.TypeParameters.Values[i]; gpData[i] = new GenericParameterData(gParam.Name); if (!visitorsDoNotNeedConstraints) { gpData[i].Constraints.AddRange(gParam.Constraints.Select(k => k.TurnTypeParametersIntoSymbols())); gpData[i].SpecialConstraint = gParam.SpecialConstraint; } } } var parameterData = new TypedNameSeries(method.Parameters.Values.Select(k => k.ParameterType.WithName(k.Name))); var newMethod = this.VisitorResult.Methods.Add(method.ReturnType.WithName(method.Name), parameterData, gpData); if (visitorsDoNotNeedConstraints) { newMethod.Implementations.Add(builder.VisitorInterface); foreach (var gpDetail in from gpDatum in gpData join genericParameter in method.TypeParameters.Values on gpDatum.Name equals genericParameter.Name select new { GenericParameterDatum = gpDatum, GenericParameter = genericParameter }) { gpDetail.GenericParameterDatum.Constraints.AddRange(gpDetail.GenericParameter.Constraints.Select(k => k.TurnTypeParametersIntoSymbols())); gpDetail.GenericParameterDatum.SpecialConstraint = gpDetail.GenericParameter.SpecialConstraint; } var secondNewMethod = this.SecondaryResult.Methods.Add(method.ReturnType.WithName(this.Detail.VisitRefactorName), parameterData, gpData); secondNewMethod.AccessLevel = AccessLevelModifiers.Public; if (this.Detail.VisitRefactorAbstract) { secondNewMethod.IsAbstract = true; } var paramRefs = parameterData.Select(k => newMethod.Parameters[k.Name].GetReference()).ToArray(); var invocation = newMethod.IsGenericConstruct ? secondNewMethod.GetReference(null, newMethod.GenericParameters).Invoke(paramRefs) : secondNewMethod.GetReference(null).Invoke(paramRefs); var firstParam = newMethod.Parameters.Values[0]; var firstParamType = firstParam.ParameterType; if (firstParamType is IInterfaceType) { foreach (var prop in EnumerateInterfaceProperties((IInterfaceType)firstParamType, ignoreAttr, inheritanceDetail, interfaceProperties)) { var propertyRelevanceInfo = IsPropertyRelevant(prop.Item1, builderInterfaces, ignoreAttr, relevantActionTypes); var requirement = prop.Item1.Metadata[requireAttr]; IBlockStatementParent codeTarget = secondNewMethod; if (propertyRelevanceInfo.Item2 != VisitorImplementationTypeRelevance.NotRelevant) { if (requirement != null) { codeTarget = codeTarget.If(firstParam.GetReference().GetProperty(requirement.Parameters.GetIndexedParameter <string>(0).Item2)); } else if (prop.Item1.PropertyType.Type == TypeKind.Interface || prop.Item1.PropertyType.Type == TypeKind.Class) { codeTarget = codeTarget.If(firstParam.GetReference().GetProperty(prop.Item1.Name).InequalTo(IntermediateGateway.NullValue)); } } switch (propertyRelevanceInfo.Item2) { case VisitorImplementationTypeRelevance.AsItem: codeTarget.Call(firstParam.GetReference().GetProperty(prop.Item1.Name).GetMethod("Accept").Invoke(new IExpression[] { this.VisitorResult.GetThis() }.Concat(newMethod.Parameters.Values.Skip(1).Select(k => k.GetReference())).ToArray())); break; case VisitorImplementationTypeRelevance.AsActionableItemSet: ProcessActionableSet(relevantActionDetailLookup, firstParam, prop, propertyRelevanceInfo, codeTarget, 0, null); break; case VisitorImplementationTypeRelevance.AsActionableValueSet: ProcessActionableSet(relevantActionDetailLookup, firstParam, prop, propertyRelevanceInfo, codeTarget, 1, "Values"); break; case VisitorImplementationTypeRelevance.AsActionableDeclValueSet: ProcessActionableSet(relevantActionDetailLookup, firstParam, prop, propertyRelevanceInfo, codeTarget, 2, "Values"); break; case VisitorImplementationTypeRelevance.AsActionableItem: IType ratType = propertyRelevanceInfo.Item1; if (ratType.IsGenericTypeParameter) { var gpRat = (IGenericParameter)(ratType); var interfaces = gpRat.Constraints.Concat(gpRat.Constraints.SelectMany(r => r.ImplementedInterfaces)).Distinct().ToArray(); ratType = interfaces.FirstOrDefault(k => relevantActionDetailLookup.ContainsKey(k)); } else if (!relevantActionDetailLookup.ContainsKey(ratType)) { var interfaces = ratType.ImplementedInterfaces; ratType = interfaces.FirstOrDefault(k => relevantActionDetailLookup.ContainsKey(k)); } var currentActionDetail = relevantActionDetailLookup[ratType]; codeTarget.Call( this.VisitorResult .GetThis() .GetMethod(currentActionDetail.TargetAction) .Invoke( firstParam .GetReference() .GetProperty(prop.Item1.Name))); break; //case VisitorImplementationTypeRelevance.AsActionableItemSet: // IType enumerableRatType = propertyRelevanceInfo.Item1; // var genericParam = ((IGenericType)(enumerableRatType)).GenericParameters.FirstOrDefault(); // if (genericParam != null) // { // if (genericParam.IsGenericTypeParameter) // { // var gpRat = (IGenericParameter)(genericParam); // var interfaces = gpRat.Constraints.Concat(gpRat.Constraints.SelectMany(r => r.ImplementedInterfaces)).Distinct().ToArray(); // genericParam = interfaces.FirstOrDefault(k => relevantActionDetailLookup.ContainsKey(k)); // } // else if (!relevantActionDetailLookup.ContainsKey(genericParam)) // { // var interfaces = genericParam.ImplementedInterfaces; // genericParam = interfaces.FirstOrDefault(k => relevantActionDetailLookup.ContainsKey(k)); // } // var currentActionSetDetail = relevantActionDetailLookup[genericParam]; // codeTarget.Call(this.VisitorResult.GetThis().GetMethod(currentActionSetDetail.TargetPluralAction).Invoke(firstParam.GetReference().GetProperty(prop.Item1.Name))); // } // break; case VisitorImplementationTypeRelevance.AsValueSet: case VisitorImplementationTypeRelevance.AsDeclValueSet: codeTarget.Call(this.VisitorResult.GetThis().GetMethod(this.Detail.VisitRefactorName ?? "Visit").Invoke(firstParam.GetReference().GetProperty(prop.Item1.Name).GetProperty("Values"))); break; case VisitorImplementationTypeRelevance.AsItemSet: codeTarget.Call(this.VisitorResult.GetThis().GetMethod(this.Detail.VisitRefactorName ?? "Visit").Invoke(firstParam.GetReference().GetProperty(prop.Item1.Name))); break; default: break; } } if (!firstParamType.Metadata.Contains(ignoreSetAttr)) { var enAccess = IsTypeRelevantForEnumerableAccess(builderInterfaces, firstParamType, relevantActionTypes); if (enAccess.Item2 == VisitorImplementationTypeRelevance.AsItemSet) { secondNewMethod.Call(this.VisitorResult.GetThis().GetMethod(this.Detail.VisitRefactorName ?? "Visit").Invoke(firstParam.GetReference().Cast(enAccess.Item1))); } } } if (isVoidReturn) { newMethod.Call(invocation); } else { newMethod.Return(invocation); } } else { } } } }
protected override TIntermediateEvent GetEvent(string name, TypedNameSeries eventSignature) { EventMember result = this.Parent.GetNewEvent(name, eventSignature); return((TIntermediateEvent)((object)(result))); }
private static void BuildStructureConstructors(IProductionRuleCaptureStructure targetStructure, OilexerGrammarProductionRuleEntry structureRoot, ITypeIdentityManager identityManager) { int stateIndex = 0; foreach (var element in targetStructure.Values) { element.StateIndex = stateIndex++; } IEnumerable <IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > > validVariations = new IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > [0]; var firstOrDefSeries = (IProductionRuleSeries)targetStructure.Sources.FirstOrDefault(k => k is IProductionRuleSeries); var firstOrDefProductionRule = (IOilexerGrammarProductionRuleEntry)targetStructure.Sources.FirstOrDefault(k => k is IOilexerGrammarProductionRuleEntry); var optg = PickOptionalGroups(firstOrDefProductionRule == null ? firstOrDefSeries : firstOrDefProductionRule, targetStructure); foreach (var parameterSet in targetStructure.Structures) { var limitedSet = (from param in parameterSet join item in targetStructure.Keys on param equals item select new { Name = item, Item = targetStructure[item] }).ToArray(); var optionalSet = (from l in limitedSet where l.Item.Optional select l).ToArray(); if (limitedSet.Length > 0) { var parameterPermutations = VariateSeries(new LockedLinkedList <IProductionRuleCaptureStructuralItem>(from l in limitedSet select l.Item).First, optg).Distinct(); validVariations = validVariations.Concat(parameterPermutations); foreach (var variation in parameterPermutations) { bool[] parameterStateFlags = (from k in variation.ToArray() select k.Item2).ToArray(); List <string> parameterResult = new List <string>(); for (int parameterIndex = 0; parameterIndex < parameterStateFlags.Length; parameterIndex++) { if (parameterStateFlags[parameterIndex]) { var limitedEntry = limitedSet[parameterIndex]; parameterResult.Add(limitedEntry.Name); } } //if (!resultantParameterSets.Any(k => k.SequenceEqual(parameterResult))) // resultantParameterSets.Add(parameterResult); } } } List <IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > > toRemove = new List <IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > >(); var exclusiveDistinctions = (from set in validVariations.Distinct().ToArray() let parameters = from parameter in set where parameter.Item2 select parameter.Item1 orderby string.Join(string.Empty, from k in parameters select k.BucketName) select new HashList <IProductionRuleCaptureStructuralItem>(parameters)).Distinct(); var stateField = targetStructure.ResultClass.Fields.Add(new TypedName("state", identityManager.ObtainTypeReference(RuntimeCoreType.Int32))); var toStringMethod = targetStructure.ResultClass.Methods.Add(new TypedName("ToString", identityManager.ObtainTypeReference(RuntimeCoreType.String))); toStringMethod.AccessLevel = AccessLevelModifiers.Public; toStringMethod.IsOverride = true; var toStringStateSwitch = toStringMethod.Switch(stateField.GetReference()); toStringMethod.Return(identityManager.ObtainTypeReference(RuntimeCoreType.String).GetTypeExpression().GetField("Empty")); var formatMethod = identityManager.ObtainTypeReference(RuntimeCoreType.String).GetTypeExpression().GetMethod("Format"); foreach (var parameterSetVariation in exclusiveDistinctions) { TypedNameSeries currentCtorTNS = new TypedNameSeries(); int currentStateValue = 0; foreach (var parameterEntry in parameterSetVariation) { var parameterName = parameterEntry.BucketName; var currentElement = targetStructure[parameterName]; IType parameterType = null; switch (currentElement.ResultType) { case ResultedDataType.EnumerationItem: case ResultedDataType.Flag: parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.Boolean); break; case ResultedDataType.Enumeration: IProductionRuleCaptureStructure enumStructure = (IProductionRuleCaptureStructure)currentElement; parameterType = enumStructure.AggregateSetEnum ?? enumStructure.ResultEnumSet[0]; break; case ResultedDataType.ComplexType: IProductionRuleCaptureStructure dualStructure = (IProductionRuleCaptureStructure)currentElement; parameterType = dualStructure.ResultInterface; break; case ResultedDataType.Counter: parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.Int32); break; case ResultedDataType.Character: parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.Char); break; case ResultedDataType.String: parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.String); break; default: throw new InvalidOperationException("Unknown parameter type."); } currentStateValue |= (int)Math.Pow(2, parameterEntry.StateIndex); currentCtorTNS.Add(LowerFirstCharacter(parameterName), parameterType); } var currentCtor = targetStructure.ResultClass.Constructors.Add(currentCtorTNS); currentCtor.AccessLevel = AccessLevelModifiers.Public; currentCtor.Assign(stateField.GetReference(), currentStateValue.ToPrimitive()); var currentStateCase = toStringStateSwitch.Case(currentStateValue.ToPrimitive()); var currentInvocation = formatMethod.Invoke(); currentStateCase.Return(currentInvocation); var currentFormat = string.Empty.ToPrimitive(); currentInvocation.Arguments.Add(currentFormat); StringBuilder formatBuilder = new StringBuilder(); bool first = true; int currentParamIndex = 0; foreach (var parameterEntry in parameterSetVariation) { if (first) { first = false; } else { formatBuilder.Append(", "); } formatBuilder.AppendFormat("{{{0}}}", currentParamIndex++); var parameterName = parameterEntry.BucketName; var currentElement = targetStructure[parameterName]; IIntermediateFieldMember currentField = currentElement.AssociatedField; currentInvocation.Arguments.Add(currentField.GetReference()); currentCtor.Assign(currentField.GetReference(), currentCtor.Parameters[LowerFirstCharacter(parameterName)].GetReference()); } currentFormat.Value = formatBuilder.ToString(); } }
protected override IIntermediateGenericParameterIndexerMember <TGenericParameter, TIntermediateGenericParameter> GetNew(TypedName nameAndReturn, TypedNameSeries parameters, bool canGet = true, bool canSet = true) { var result = new IndexerMember(nameAndReturn.Name, this.Parent, this.Parent.Assembly); if (parameters.Count > 0) { result.Parameters.AddRange(parameters.ToArray()); } result.PropertyType = nameAndReturn.TypeReference; result.CanRead = canGet; result.CanWrite = canSet; return(result); }
IIntermediateEventMember IIntermediateEventMemberDictionary.Add(string name, TypedNameSeries eventSignature) { return(this.Add(name, eventSignature)); }