Authoring Support: Add WinRT Diagnostics

src/Authoring/TestDiagnostics/ArrayParameterTests.cs

@@ -0,0 +1,132 @@
+using System.Runtime.InteropServices;
+
+namespace TestDiagnostics
+{
+    /* TODO: 
+     * what happens if you put another random attribute on an array param? 
+     * check in WRC3 project ...
+    */
+    public class ReadOnlyArray : System.Attribute
+    {
+        public ReadOnlyArray() { }
+    }
+
+    public class WriteOnlyArray : System.Attribute
+    {
+        public WriteOnlyArray() { }
+    }
+
+    /*
+    public interface IHaveAMethodNamedArray_Valid
+    {
+        void Array(int i);
+        int[] Foo(out int[] arr);
+    }
+
+    public sealed class OutParam_Valid
+    {
+        public void Foo(out int[] arr) { arr = new int[] { }; }
+    }
+
+    // method with `ref` param 
+    public sealed class OnlyParam
+    {
+        //  array param with both attributes 
+        public void BothAttributes_Separate([WriteOnlyArray()][ReadOnlyArray()] int[] arr) { }
+
+        public void BothAttributes_Together([WriteOnlyArray(), ReadOnlyArray()] int[] arr) { }
+
+        // array marked `out` but marked with ReadOnlyArray Attribute
+        public void MarkedOutAndReadOnly([ReadOnlyArray()] out int[] arr) { arr = new int[] { }; }
+        public void MarkedReadOnly_Valid([ReadOnlyArray()] int[] arr) { }
+
+        // Valid WriteOnlyArray Tests
+        public void MarkedWriteOnly_Valid([WriteOnlyArray()] int[] arr) { }
+        public void MarkedOutAndWriteOnly_Valid([WriteOnlyArray()] out int[] arr) { arr = new int[] { }; }
+        public void MarkedOutOnly_Valid(out int[] arr) { arr = new int[] { }; }
+
+        // param is array, and marked either InAttribute or OutAttribute
+        // must have ReadOnlyArray or WriteOnlyArray
+        public void ArrayMarkedIn([In] int[] arr) { }
+        public void ArrayMarkedOut([Out] int[] arr) { }
+
+        // method has param marked with  ReadOnlyArray / WriteOnlyArray 
+        //  but param isnt array
+        public void NonArrayMarkedReadOnly([ReadOnlyArray()] int arr) { }
+        public void NonArrayMarkedWriteOnly([WriteOnlyArray()] int arr) { }
+
+        // param marked InAttribute or OutAttribute , disallowed in total  
+        public void ParamMarkedIn([In] int arr) { }
+        public void ParamMarkedOut([Out] int arr) { }
+
+        // array as param but not marked either way
+        public void ArrayNotMarked(int[] arr) { }
+
+        public void ArrayNotMarked_Valid(out int[] arr) { arr = new int[] { };  }
+    }
+
+    public sealed class TwoParam
+    { 
+         public void BothAttributes(int i, [WriteOnlyArray()][ReadOnlyArray()] int[] arr) { }
+        // array marked `out` but marked with ReadOnlyArray Attribute
+        public void MarkedOutAndReadOnly(int i, [ReadOnlyArray()] out int[] arr) { arr = new int[] { }; }
+        public void MarkedReadOnly_Valid(int i, [ReadOnlyArray()] int[] arr) { }
+
+        // Valid WriteOnlyArray Tests
+        public void MarkedWriteOnly_Valid(int i, [WriteOnlyArray()] int[] arr) { }
+        public void MarkedOutAndWriteOnly_Valid(int i, [WriteOnlyArray()] out int[] arr) { arr = new int[] { }; }
+        public void MarkedOut_Valid(int i, out int[] arr) { arr = new int[] { }; }
+
+        // param is array, and marked either InAttribute or OutAttribute
+        // must have ReadOnlyArray or WriteOnlyArray
+        public void ArrayMarkedIn(int i, [In] int[] arr) { }
+        public void ArrayMarkedOut(int i, [Out] int[] arr) { }
+
+        // method has param marked with  ReadOnlyArray / WriteOnlyArray 
+        //  but param isnt array
+        public void NonArrayMarkedReadOnly(int i, [ReadOnlyArray()] int arr) { }
+        public void NonArrayMarkedWriteOnly(int i, [WriteOnlyArray()] int arr) { }
+
+        // param marked InAttribute or OutAttribute , disallowed in total  
+        public void ParamMarkedIn(int i, [In] int arr) { } // hey!
+        public void ParamMarkedOut(int i, [Out] int arr) { }
+
+        // array as param but not marked either way
+        public void ArrayNotMarked(int i, int[] arr) { }
+    }
+
+    public sealed class TwoArrays
+    { 
+        public void OneValidOneInvalid_1([WriteOnlyArray] int[] xs, [WriteOnlyArray()][ReadOnlyArray()] int[] ys) { }
+        public void OneValidOneInvalid_2([WriteOnlyArray][ReadOnlyArray()] int[] xs, [WriteOnlyArray()] int[] ys) { }
+
+        // array marked `out` but marked with ReadOnlyArray Attribute
+        public void MarkedOutAndReadOnly([ReadOnlyArray()] int[] xs, [ReadOnlyArray()] out int[] arr) { arr = new int[] { }; }
+        public void MarkedReadOnly_Valid([ReadOnlyArray()] int[] xs, [ReadOnlyArray()] int[] arr) { }
+
+        // Valid WriteOnlyArray Tests
+        public void MarkedWriteOnly_Valid([ReadOnlyArray()] int[] xs, [WriteOnlyArray()] int[] arr) { }
+        public void MarkedOutAndWriteOnly_Valid([ReadOnlyArray()] int[] xs, [WriteOnlyArray()] out int[] arr) { arr = new int[] { }; }
+        public void MarkedOut_Valid([WriteOnlyArray()] int[] xs, out int[] arr) { arr = new int[] { }; }
+
+        // param is array, and marked either InAttribute or OutAttribute
+        // must have ReadOnlyArray or WriteOnlyArray
+        public void ArrayMarkedIn(int i, [In] int[] arr) { }
+        public void ArrayMarkedIn2([ReadOnlyArray()] int[] xs, [In] int[] arr) { }
+        public void ArrayMarkedOut([ReadOnlyArray()] int[] xs, [Out] int[] arr) { }
+
+        // method has param marked with  ReadOnlyArray / WriteOnlyArray but param isnt array
+        public void NonArrayMarkedReadOnly([ReadOnlyArray()] int[] xs, [ReadOnlyArray()] int i) { }
+        public void NonArrayMarkedWriteOnly([ReadOnlyArray()] int[] xs, [WriteOnlyArray()] int i) { }
+        public void NonArrayMarkedWriteOnly2([ReadOnlyArray()] int i, [WriteOnlyArray()] int[] arr) { }
+
+        // param marked InAttribute or OutAttribute , disallowed in total  
+        public void ParamMarkedIn([ReadOnlyArray()] int[] xs, [In] int arr) { }
+        public void ParamMarkedOut([ReadOnlyArray()] int[] xs, [Out] int arr) { }
+        public void ParamMarkedOut2([Out] int arr, [ReadOnlyArray()] int[] xs) { }
+
+        // array as param but not marked either way
+        public void ArrayNotMarked([ReadOnlyArray()] int[] xs, int[] arr) { }
+    }
+    */
+}

src/Authoring/TestDiagnostics/AsyncInterfaceTests.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.Foundation;
+
+namespace TestDiagnostics
+{ 
+    /*
+    public sealed class AsyAction : IAsyncAction, IAsyncActionWithProgress<int>
+    {
+        public AsyncActionCompletedHandler Completed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public Exception ErrorCode => throw new NotImplementedException();
+
+        public uint Id => throw new NotImplementedException();
+
+        public AsyncStatus Status => throw new NotImplementedException();
+
+        AsyncActionProgressHandler<int> IAsyncActionWithProgress<int>.Progress { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        AsyncActionWithProgressCompletedHandler<int> IAsyncActionWithProgress<int>.Completed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        Exception IAsyncInfo.ErrorCode => throw new NotImplementedException();
+
+        uint IAsyncInfo.Id => throw new NotImplementedException();
+
+        AsyncStatus IAsyncInfo.Status => throw new NotImplementedException();
+
+        public void Cancel()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Close()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void GetResults()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+
+    public class ActionWithProgress : IAsyncActionWithProgress<int>
+    {
+        AsyncActionProgressHandler<int> IAsyncActionWithProgress<int>.Progress { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        AsyncActionWithProgressCompletedHandler<int> IAsyncActionWithProgress<int>.Completed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        Exception IAsyncInfo.ErrorCode => throw new NotImplementedException();
+
+        uint IAsyncInfo.Id => throw new NotImplementedException();
+
+        AsyncStatus IAsyncInfo.Status => throw new NotImplementedException();
+
+        void IAsyncInfo.Cancel()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IAsyncInfo.Close()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IAsyncActionWithProgress<int>.GetResults()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public sealed class OpWithProgress : IAsyncOperationWithProgress<int, bool>
+    {
+        AsyncOperationProgressHandler<int, bool> IAsyncOperationWithProgress<int, bool>.Progress { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        AsyncOperationWithProgressCompletedHandler<int, bool> IAsyncOperationWithProgress<int, bool>.Completed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        Exception IAsyncInfo.ErrorCode => throw new NotImplementedException();
+
+        uint IAsyncInfo.Id => throw new NotImplementedException();
+
+        AsyncStatus IAsyncInfo.Status => throw new NotImplementedException();
+
+        void IAsyncInfo.Cancel()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IAsyncInfo.Close()
+        {
+            throw new NotImplementedException();
+        }
+
+        int IAsyncOperationWithProgress<int, bool>.GetResults()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public sealed class Op : IAsyncOperation<int>
+    {
+        AsyncOperationCompletedHandler<int> IAsyncOperation<int>.Completed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        Exception IAsyncInfo.ErrorCode => throw new NotImplementedException();
+
+        uint IAsyncInfo.Id => throw new NotImplementedException();
+
+        AsyncStatus IAsyncInfo.Status => throw new NotImplementedException();
+
+        void IAsyncInfo.Cancel()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IAsyncInfo.Close()
+        {
+            throw new NotImplementedException();
+        }
+
+        int IAsyncOperation<int>.GetResults()
+        {
+            throw new NotImplementedException();
+        }
+    }
+    */
+}

src/Authoring/TestDiagnostics/Directory.Build.props

@@ -0,0 +1,9 @@
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" >
+
+  <PropertyGroup>
+    <SimulateCsWinRTNugetReference>true</SimulateCsWinRTNugetReference>
+  </PropertyGroup>
+
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
+
+</Project>

src/Authoring/TestDiagnostics/Directory.Build.targets

@@ -0,0 +1,9 @@
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <Target Name="CopyWinMD" AfterTargets="AfterBuild">
+    <Copy SourceFiles="$(GeneratedFilesDir)$(AssemblyName).winmd" DestinationFolder="$(OutputPath)" />
+  </Target>
+
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)../'))" />
+
+</Project>