public override TypeNode InferTypeOfBinaryExpression(TypeNode t1, TypeNode t2, BinaryExpression binaryExpression) { // // For addition or subtraction operations involving a set (as either operand) // the result will be a set of the same type. Later, in the Checker, we'll // verify that the combination of operands is valid. Here, we can quickly infer // the type of the result. // switch (binaryExpression.NodeType) { case NodeType.Add: case NodeType.Sub: if (t1 is Set) return t1; else if (t2 is Set) return t2; break; case (NodeType)ZingNodeType.In: return SystemTypes.Boolean; default: break; } return base.InferTypeOfBinaryExpression(t1, t2, binaryExpression); }
/** * <summary>IsExposedType compares the given type to itself. If this filter * contains a '.' designating it as for a nested class it will skip * non-nested classes. Classes with no declaring types will not be compared to * filters with a '.' * </summary> */ public bool? IsExposedType(TypeNode type) { bool? typeIsExposed = null; //check if the type was nested if (type.DeclaringType == null) { if (type.Name.Name == name) typeIsExposed = exposed; } //if we are nested then check if this filter is for a nested class //check that nothing used is null also. //if the name attribute is not there in the config name can be null here. else if (name != null && name.Contains(".")) { //Get a stack of declaring type names Stack < string > parentNames = new Stack < string >(); parentNames.Push(type.Name.Name); //start with this one TypeNode parent = type.DeclaringType; while (parent != null) { parentNames.Push(parent.Name.Name); parent = parent.DeclaringType; } //put them back in the correct order and check the name if (name.Equals(String.Join(".", parentNames.ToArray()))) typeIsExposed = exposed; } return typeIsExposed; }
public CollectOldExpressions(Module module, Method method, ContractNodes contractNodes, Dictionary<TypeNode, Local> closureLocals, int localCounterStart, Class initialClosureClass) : this(module, method, contractNodes, closureLocals, localCounterStart) { this.topLevelClosureClass = initialClosureClass; this.currentClosureClass = initialClosureClass; }
private CurrentState(TypeNode type, Dictionary<string, object> typeSuppressed, Method method) { this.Type = type; this.typeSuppressed = typeSuppressed; this.Method = method; this.methodSuppressed = null; }
public override string GetTypeName(TypeNode type) { using (TextWriter writer = new StringWriter()) { writer.Write("T:"); WriteType(type, writer); return (writer.ToString()); } }
public static Namespace GetNamespace(TypeNode type) { if (type.DeclaringType != null) { return (GetNamespace(type.DeclaringType)); } else { return (new Namespace(type.Namespace)); } }
/// <summary> /// Returns a list of CfgBlock that are handlers of the current block, handling an exception /// of the given type, or a subtype thereof. /// </summary> /// <param name="exception">Type of exception thrown. It is assumed that any actual subtype could be thrown</param> /// <returns>All handlers that could apply directly to this exception. /// In addition, if the method might not handle it, then the ExceptionExit block is /// part of this list.</returns> public System.Collections.IEnumerable/*CfgBlock*/ HandlersMatching(TypeNode exception) { ArrayList handlers = new ArrayList(); CfgBlock currentBlock = this; while (currentBlock != null) { CfgBlock handler = this.cfg.ExceptionHandler(currentBlock); if (handler == null || handler.Statements == null || handler.Statements.Count < 1) break; Catch stat = handler.Statements[0] as Catch; if (stat != null) { if (exception.IsAssignableTo(stat.Type)) { // handles exceptions completely handlers.Add(handler); break; } if (stat.Type.IsAssignableTo(exception)) { // handles part of it handlers.Add(handler); } currentBlock = handler; } else { // must be the Unwind block handlers.Add(handler); break; } } return handlers; }
// // We add an implicit conversion from "object" to any of our heap-allocated // types. // // We also permit implicit conversions between "int" and "byte". // // TODO: We may need to construct a more elaborate expression here for the // conversion to permit the runtime to make the appropriate checks. // public override bool ImplicitCoercionFromTo(Expression source, TypeNode t1, TypeNode t2) { if (t1 == SystemTypes.Object) { if (t2 is Chan || t2 is Set || t2 is ZArray || t2 is Class) return true; else return false; } if (t2 == SystemTypes.Object) { if (t1 is Chan || t1 is Set || t1 is ZArray || t1 is Class) return true; else return false; } if (t1 == SystemTypes.Int32 && t2 == SystemTypes.UInt8) return true; if (t1 == SystemTypes.UInt8 && t2 == SystemTypes.Int32) return true; return base.ImplicitCoercionFromTo(source, t1, t2); }
public override Expression CoerceAnonymousNestedFunction(AnonymousNestedFunction func, TypeNode targetType, bool explicitCoercion, TypeViewer typeViewer) { if (func is AnonymousNestedDelegate && !(targetType is DelegateNode)) { this.HandleError(func, Error.AnonMethToNonDel, this.GetTypeName(targetType)); return null; } return base.CoerceAnonymousNestedFunction(func, targetType, explicitCoercion, typeViewer); }
/// <param name="module">The module into which the duplicate IR will be grafted.</param> /// <param name="type">The type into which the duplicate Member will be grafted. Ignored if entire type, or larger unit is duplicated.</param> public Duplicator(Module/*!*/ module, TypeNode type) { this.TargetModule = module; this.TargetType = this.OriginalTargetType = type; this.DuplicateFor = new TrivialHashtable(); this.TypesToBeDuplicated = new TrivialHashtable(); //^ base(); }
/// <inheritdoc /> public override string GetTypeName(TypeNode type) { StringBuilder sb = new StringBuilder("T:"); WriteType(type, sb); return sb.ToString(); }
public CurrentState(AssemblyNode assembly) { this.Assembly = assembly; this.Type = null; this.Method = null; this.assemblySuppressed = null; this.typeSuppressed = null; this.methodSuppressed = null; }
public override void VisitTypeNode(TypeNode typeNode) { if (typeNode == null) return; ScrubAttributeList(typeNode.Attributes); this.VisitMemberList(typeNode.Members); }
public DuplicatorForContractsAndClosures(Module module, Method sourceMethod, Method targetMethod, ContractNodes contractNodes, bool mapParameters) : base(module, targetMethod.DeclaringType) { this.sourceMethod = sourceMethod; this.targetMethod = targetMethod; this.RemoveNameForLocals = true; Duplicator dup = this; if (mapParameters) { if (sourceMethod.ThisParameter != null) { if (targetMethod.ThisParameter != null) { dup.DuplicateFor[sourceMethod.ThisParameter.UniqueKey] = targetMethod.ThisParameter; } else { // target is a static wrapper. But duplicator cannot handle This -> Parameter conversion // so we handle it explicitly here in this visitor. replaceThisWithParameter = targetMethod.Parameters[0]; } } if (sourceMethod.Parameters != null && targetMethod.Parameters != null && sourceMethod.Parameters.Count == targetMethod.Parameters.Count) { for (int i = 0, n = sourceMethod.Parameters.Count; i < n; i++) { dup.DuplicateFor[sourceMethod.Parameters[i].UniqueKey] = targetMethod.Parameters[i]; } } } var originalType = HelperMethods.IsContractTypeForSomeOtherType(sourceMethod.DeclaringType, contractNodes); if (originalType != null) { var contractType = this.contractClass = sourceMethod.DeclaringType; while (contractType.Template != null) { contractType = contractType.Template; } while (originalType.Template != null) { originalType = originalType.Template; } // forward ContractType<A,B> -> originalType<A',B'> this.contractClassToForward = contractType; this.targetTypeToForwardTo = originalType; //dup.DuplicateFor[contractType.UniqueKey] = originalType; } }
//Find out if any are exposed incase this class is not exposed public bool HasExposedMembers(TypeNode type) { foreach (Member member in type.Members) foreach (MemberFilter memberFilter in memberFilters) if (memberFilter.IsExposedMember(member) == true) return true; return false; }
public static bool IsRuntimeIgnored(Node node, ContractNodes contractNodes, TypeNode referencingType, bool skipQuantifiers) { CodeInspector ifrv = new CodeInspector( ContractNodes.RuntimeIgnoredAttributeName, contractNodes, referencingType, skipQuantifiers); ifrv.Visit(node); return ifrv.foundAttribute; }
private CurrentState(Method method, CurrentState oldState) { this.Assembly = oldState.Assembly; this.assemblySuppressed = oldState.assemblySuppressed; this.Type = oldState.Type; this.typeSuppressed = oldState.typeSuppressed; this.Method = method; this.methodSuppressed = null; }
public ScrubContractClass(ExtractorVisitor parent, Class contractClass, TypeNode originalType) { Contract.Requires(TypeNode.IsCompleteTemplate(contractClass)); Contract.Requires(TypeNode.IsCompleteTemplate(originalType)); this.parent = parent; this.contractClass = contractClass; this.abstractClass = originalType; }
public CurrentState(TypeNode type, CurrentState oldState) { this.Type = type; this.Method = null; this.typeSuppressed = null; this.methodSuppressed = null; this.Assembly = oldState.Assembly; this.assemblySuppressed = oldState.assemblySuppressed; }
/// <summary> /// actualReturn type is null if Task is not generic, otherwise ,the Task result type. /// </summary> public static bool Contains(Node node, ContractNodes contractNodes, Method currentMethod, TypeNode actualReturnType) { var v = new AsyncReturnValueQuery(contractNodes, currentMethod, actualReturnType); v.Visit(node); return v.foundReturnValueTaskResult; }
// we are satistied with the default namespace expose test, so don't override it public override bool IsExposedType(TypeNode type) { if (type == null) throw new ArgumentNullException("type"); // expose any visible types allowed by the base filter if (type.IsVisibleOutsideAssembly) { return (base.IsExposedType(type)); } else { return (false); } // return(type.IsVisibleOutsideAssembly); }
public override Method VisitMethod(Method method) { Method re = base.VisitMethod(method); System.Compiler.TypeNode sigTmp = re.ReturnType; if(sigTmp.TypeCode!=TypeCode.Empty) signatureType = sigTmp; return re; }
/// <summary> /// /// </summary> /// <param name="writer"></param> /// <param name="type">the current type being extended</param> /// <param name="extensionMethodTemplate">A reference to the extension method. For generic methods, this is a reference to the /// non-specialized method, e.g. System.Linq.Enumerable.Select``2. /// </param> /// <param name="specialization">When the current type implements or inherits from a specialization of a generic type, /// this parameter has a TypeNode for the type used as apecialization of the generic type's first template param. /// </param> private void AddExtensionMethod(XmlWriter writer, TypeNode type, Method extensionMethodTemplate, TypeNode specialization) { // If this is a specialization of a generic method, construct a Method object that describes the specialization Method extensionMethodTemplate2 = extensionMethodTemplate; if (extensionMethodTemplate2.IsGeneric && (specialization != null)) { // the specialization type is the first of the method's template arguments TypeNodeList templateArgs = new TypeNodeList(); templateArgs.Add(specialization); // add any additional template arguments for (int i = 1; i < extensionMethodTemplate.TemplateParameters.Count; i++) templateArgs.Add(extensionMethodTemplate.TemplateParameters[i]); extensionMethodTemplate2 = extensionMethodTemplate.GetTemplateInstance(type, templateArgs); } TypeNode extensionMethodTemplateReturnType = extensionMethodTemplate2.ReturnType; ParameterList extensionMethodTemplateParameters = extensionMethodTemplate2.Parameters; ParameterList extensionMethodParameters = new ParameterList(); for (int i = 1; i < extensionMethodTemplateParameters.Count; i++) { Parameter extensionMethodParameter = extensionMethodTemplateParameters[i]; extensionMethodParameters.Add(extensionMethodParameter); } Method extensionMethod = new Method(extensionMethodTemplate.DeclaringType, new AttributeList(), extensionMethodTemplate.Name, extensionMethodParameters, extensionMethodTemplate.ReturnType, null); extensionMethod.Flags = extensionMethodTemplate.Flags & ~MethodFlags.Static; // for generic methods, set the template args and params so the template data is included in the id and the method data if (extensionMethodTemplate2.IsGeneric) { extensionMethod.IsGeneric = true; if (specialization != null) { // set the template args for the specialized generic method extensionMethod.TemplateArguments = extensionMethodTemplate2.TemplateArguments; } else { // set the generic template params for the non-specialized generic method extensionMethod.TemplateParameters = extensionMethodTemplate2.TemplateParameters; } } // Get the id string extensionMethodTemplateId = reflector.ApiNamer.GetMemberName(extensionMethodTemplate); // write the element node writer.WriteStartElement("element"); writer.WriteAttributeString("api", extensionMethodTemplateId); writer.WriteAttributeString("source", "extension"); isExtensionMethod = true; reflector.WriteMember(extensionMethod); isExtensionMethod = false; writer.WriteEndElement(); }
public override Expression ImplicitCoercion(Expression source, TypeNode targetType, TypeViewer typeViewer) { // LJW: added third parameter "typeViewer" so we override the correct thing if (source == null || source.Type == null || targetType == null) return null; if (source.Type is EnumNode && targetType == SystemTypes.Int32) { return source; } if (source.Type == SystemTypes.Object) { if (targetType is Chan || targetType is Set || targetType is ZArray || targetType is Class) return source; else { this.HandleError(source, System.Compiler.Error.NoImplicitCoercion, "object", targetType.FullName); return null; } } if (targetType == SystemTypes.Object) { if (!(source.Type is Chan || source.Type is Set || source.Type is ZArray || source.Type is Class)) { this.HandleError(source, System.Compiler.Error.NoImplicitCoercion, source.Type.FullName, "object"); return null; } } if (source.Type == SystemTypes.Int32 && targetType == SystemTypes.UInt8) { BinaryExpression binExpr = new BinaryExpression(source, new MemberBinding(null, SystemTypes.UInt8), NodeType.Castclass, source.SourceContext); binExpr.Type = SystemTypes.UInt8; return binExpr; } if (source.Type == SystemTypes.UInt8 && targetType == SystemTypes.Int32) { BinaryExpression binExpr = new BinaryExpression(source, new MemberBinding(null, SystemTypes.Int32), NodeType.Castclass, source.SourceContext); binExpr.Type = SystemTypes.Int32; return binExpr; } return base.ImplicitCoercion(source, targetType, typeViewer); }
//Find out if any are exposed incase this class is not exposed public bool HasExposedMembers(TypeNode type) { foreach (NamespaceFilter namespaceFilter in namespaceFilters) { bool? result = namespaceFilter.IsExposedType(type); if (result != null) { return namespaceFilter.HasExposedMembers(type); } } return false; }
//===================================================================== /// <summary> /// This is used to find out if the given type is required /// </summary> /// <param name="type">The type to check</param> /// <returns>True if the type is required, false if not</returns> public bool IsRequiredType(TypeNode type) { foreach(NamespaceFilter namespaceFilter in namespaceFilters) { bool? result = namespaceFilter.IsRequiredType(type); if(result != null) return result.Value; } return false; }
private void TryAddTypeToMembersToDuplicate(TypeNode type) { TypeNode template = type; while (template.Template != null) { template = template.Template; } if (!this.MembersToDuplicate.Contains(template)) { this.MembersToDuplicate.Add(template); } }
private static FieldFlags MapTypeVisibilityToFieldVisibility(TypeNode type){ TypeFlags flags = type.Flags & TypeFlags.VisibilityMask; switch (flags){ case TypeFlags.Public: case TypeFlags.NestedPublic: return FieldFlags.Public; case TypeFlags.NotPublic: case TypeFlags.NestedAssembly: return FieldFlags.Assembly; case TypeFlags.NestedFamANDAssem: return FieldFlags.FamANDAssem; case TypeFlags.NestedFamily: return FieldFlags.Family; case TypeFlags.NestedFamORAssem: return FieldFlags.FieldAccessMask; default: return FieldFlags.Private; } }
private CodeInspector(Identifier attributeToFind, ContractNodes contractNodes, TypeNode referencingType, bool skipQuantifiers) { this.foundAttribute = false; this.attributeToFind = attributeToFind; this.contractNodes = contractNodes; this.skipQuantifiers = skipQuantifiers; this.referencingType = new Stack<TypeNode>(); if (referencingType != null) { this.referencingType.Push(referencingType); } }
public static bool IsVoid (TypeNode type) { TypeModifier mtype = type as TypeModifier; if (mtype != null) { return IsVoid(mtype.ModifiedType); } if (type != null && type.Equals(Cci.SystemTypes.Void)) { return true; } return false; }