private void PropagateReferences(MethodInvocationExpression enumerableConstructorInvocation,
                                         MethodInvocationExpression enumeratorConstructorInvocation)
        {
            // propagate the necessary parameters from
            // the enumerable to the enumerator
            foreach (ParameterDeclaration parameter in _generator.Method.Parameters)
            {
                var myParam = MapParamType(parameter);

                var entity = (InternalParameter)myParam.Entity;
                if (entity.IsUsed)
                {
                    enumerableConstructorInvocation.Arguments.Add(CodeBuilder.CreateReference(myParam));

                    PropagateFromEnumerableToEnumerator(enumeratorConstructorInvocation,
                                                        entity.Name,
                                                        entity.Type);
                }
            }

            // propagate the external self reference if necessary
            if (null != _externalEnumeratorSelf)
            {
                var type = (IType)_externalEnumeratorSelf.Type.Entity;
                enumerableConstructorInvocation.Arguments.Add(
                    CodeBuilder.CreateSelfReference(_methodToEnumerableMapper.MapType(type)));

                PropagateFromEnumerableToEnumerator(enumeratorConstructorInvocation,
                                                    "self_",
                                                    _methodToEnumeratorMapper.MapType(type));
            }
        }
示例#2
0
        protected override void PropagateReferences()
        {
            // propagate the necessary parameters from
            // the enumerable to the enumerator
            foreach (ParameterDeclaration parameter in _method.Method.Parameters)
            {
                var myParam = MapParamType(parameter);

                var entity = (InternalParameter)myParam.Entity;
                if (entity.IsUsed)
                {
                    _enumerableConstructorInvocation.Arguments.Add(CodeBuilder.CreateReference(myParam));

                    PropagateFromEnumerableToEnumerator(_stateMachineConstructorInvocation,
                                                        entity.Name,
                                                        entity.Type);
                }
            }

            // propagate the external self reference if necessary
            if (_externalSelfField != null)
            {
                var type = (IType)_externalSelfField.Type.Entity;
                _enumerableConstructorInvocation.Arguments.Add(
                    CodeBuilder.CreateSelfReference(_methodToEnumerableMapper.MapType(type)));

                PropagateFromEnumerableToEnumerator(_stateMachineConstructorInvocation,
                                                    "self_",
                                                    _methodToStateMachineMapper.MapType(type));
            }
        }
示例#3
0
 public static IType MapTypeInMethodContext(IType type, Ast.Method method, out GeneratorTypeReplacer mapper)
 {
     if (type.GenericInfo != null && type.ConstructedInfo == null)
     {
         var td           = method.GetAncestor <Ast.TypeDefinition>();
         var allGenParams = td.GenericParameters.Concat(method.GenericParameters)
                            .Select(gp => (IGenericParameter)gp.Entity).ToArray();
         mapper = new GeneratorTypeReplacer();
         foreach (var genParam in type.GenericInfo.GenericParameters)
         {
             mapper.Replace(genParam, allGenParams.First(gp => gp.Name.Equals(genParam.Name)));
         }
         return(mapper.MapType(type));
     }
     mapper = null;
     return(type);
 }