C# TypeNode.GetTemplateInstance方法代码示例

//.........这里部分代码省略.........
          if (type.Template != null)
          {
            Debug.Assert(TypeNode.IsCompleteTemplate(type.Template));
            // map consolidated arguments
            bool mustSpecializeFurther = false;
            TypeNodeList targs = type.ConsolidatedTemplateArguments;
            int numArgs = targs == null ? 0 : targs.Count;
            if (targs != null)
            {
              targs = targs.Clone();
              for (int i = 0; i < numArgs; i++)
              {
                TypeNode targ = targs[i];
                targs[i] = this.VisitTypeReference(targ);
                if (targ != targs[i]) { mustSpecializeFurther = true; }
              }
            }
            if (targs == null || !mustSpecializeFurther) return type;
            TypeNode t = type.Template.GetGenericTemplateInstance(this.TargetModule, targs);
            return t;
          }
          return type;
#if OLD
          TypeNode declaringType = this.VisitTypeReference(type.DeclaringType);
          if (declaringType != null){
            Identifier tname = type.Name;
            if (type.Template != null && type.IsGeneric) tname = type.Template.Name;
            TypeNode nt = declaringType.GetNestedType(tname);
            if (nt != null){
              TypeNodeList arguments = type.TemplateArguments;
              type = nt;
              if (TargetPlatform.UseGenerics) {
                if (arguments != null && arguments.Count > 0 && nt.ConsolidatedTemplateParameters != null && nt.ConsolidatedTemplateParameters.Count > 0)
                  type = nt.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, arguments);
              }
            }
          }
          if (type.Template != null && (type.ConsolidatedTemplateParameters == null || type.ConsolidatedTemplateParameters.Count == 0)){
            if (!type.IsNotFullySpecialized && !type.IsNormalized) return type;
            //Type is a template instance, but some of its arguments were themselves parameters.
            //See if any of these parameters are to be specialized by this specializer.
            bool mustSpecializeFurther = false;
            TypeNodeList targs = type.TemplateArguments;
            int numArgs = targs == null ? 0 : targs.Count;
            if (targs != null) {
              targs = targs.Clone();
              for (int i = 0; i < numArgs; i++) {
                TypeNode targ = targs[i];
                ITypeParameter tparg = targ as ITypeParameter;
                if (tparg != null) {
                  for (int j = 0, np = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; j < np && j < m; j++) {
                    //^ assert pars != null && args != null;
                    if (TargetPlatform.UseGenerics) {
                      ITypeParameter par = pars[j] as ITypeParameter;
                      if (par == null) continue;
                      if (tparg == par || (tparg.ParameterListIndex == par.ParameterListIndex && tparg.DeclaringMember == par.DeclaringMember)) {
                        targ = this.args[j]; break;
                      }
                    }
                    else {
                      if (targ == pars[j]) { targ = this.args[j]; break; }
                    }
                  }
                } else {
                  if (targ != type)
                    targ = this.VisitTypeReference(targ);

 public virtual TypeNode GetDummyInstance(TypeNode t){
   if (t == null){Debug.Assert(false); return null;}
   if (this.currentTypeInstance != null){
     TypeNode nt = this.GetTypeView(this.currentTypeInstance).GetNestedType(t.Name);
     if (nt == null){Debug.Assert(false); return null;}
     if (nt.TemplateParameters == null || nt.TemplateParameters.Count == 0) return nt;
     t = nt;
   }
   return t.GetTemplateInstance(this.currentModule, null, t.DeclaringType, t.TemplateParameters);
 }

	void PTypeRef(out TypeNode tn) {
		Module assem = null;
		string ns, tname, nestedname;
		ArrayList/*<string>*/ typeNames;
		TypeNodeList templateArgs = null;
		
		if (la.kind == 28) {
			Assembly(out assem);
		}
		QualName(out ns, out tname);
		NestedTypeName(out typeNames, out nestedname);
		if (la.kind == 31) {
			Get();
			TypeNode arg; 
			PType(out arg);
			templateArgs = new TypeNodeList(); templateArgs.Add(arg); 
			while (la.kind == 23) {
				Get();
				PType(out arg);
				templateArgs.Add(arg); 
			}
			Expect(32);
		}
		if ( assem == null ){
		 assem = currentAssembly;
		}
		#if !WHIDBEY
		if (templateArgs != null){
		 /* then need to create the pseudo-generic name */
		 string pseudoGenericName = tname;
		 /*pseudoGenericName += SystemTypes.GenericTypeNamesMangleChar;*/
		 /*pseudoGenericName += templateArgs.Count.ToString();*/
		 pseudoGenericName += "<";
		 for (int i = 0, n = templateArgs.Count; i < n; i++){
		   if (i > 0)
		     pseudoGenericName += ",";
		   pseudoGenericName += templateArgs[i].FullName;
		 }
		 pseudoGenericName += ">";
		 tname = pseudoGenericName;
		}
		#endif
		tn = assem.GetType(Identifier.For(ns),Identifier.For(tname));
		if (tn == null) {
		 this.errors.SemErr(t.filename, t.line, t.col,
		               String.Format("could not resolve namespace {0}, type {1}", ns, tname));
		 throw new Exception("cannot continue"); //Errors.Exception("cannot continue");
		}
		// now do nested types
		for (int i=0; i<typeNames.Count; i++){
		 tn = tn.GetNestedType(Identifier.For((string)typeNames[i]));
		}
		if (tn == null) {
		 this.errors.SemErr(t.filename, t.line, t.col,
		               String.Format("could not resolve namespace {0} type {1} nesting {2}", ns, tname, nestedname));
		 throw new Exception("cannot continue"); //Errors.Exception("cannot continue");
		}
		#if WHIDBEY
		/* Pre-Whidbey, templateArgs are used to construct a pseudo-generic name */
		if (templateArgs != null)
		{
		 tn = tn.GetTemplateInstance(assem, null, null, templateArgs);
		}
		#endif
		
	}

 public virtual TypeNode GetDummyInstance(TypeNode t){
   if (t == null || t.ConsolidatedTemplateParameters == null || t.ConsolidatedTemplateParameters.Count == 0) return t;
   if (t.DeclaringType != null){
     TypeNode dt = this.GetDummyInstance(t.DeclaringType);
     if (dt != null){
       t = this.GetTypeView(dt).GetNestedType(t.Name);
       if (t == null || t.TemplateParameters == null || t.TemplateParameters.Count == 0) return t;
     }
   }
   t = t.GetTemplateInstance(this.currentType, t.TemplateParameters);
   this.AddTemplateInstanceToList(t);
   return t;
 }

        public This ThisExpression(TypeNode type)
        {
            var result = new This();
            result.Type =
                type.IsGeneric && type.TemplateParameters != null ?
                    type.GetTemplateInstance(type, type.TemplateParameters.ToArray()) :
                    type;

            return result;
        }

 public Expression FirstOrderTypeOfExpression(TypeNode hkType)
 {
     var classTypeParameters = default(Seq<TypeNode>);
     ExplodeTypeAbstraction(hkType, out classTypeParameters);
     if (classTypeParameters == null || classTypeParameters.Count == 0)
         return TypeOfExpression(hkType);
     else
     {
         var types = new TypeNode[classTypeParameters.Count];
         classTypeParameters.CopyTo(types, 0);
         var type = hkType.GetTemplateInstance(hkType, types);
         return TypeOfExpression(type);
     }
 }