react-native-windows 0.70.8 → 0.71.0-preview.1

package/Microsoft.ReactNative.Managed.CodeGen/CodeAnalyzer.cs

@@ -19,871 +19,933 @@ using System.Threading.Tasks.Dataflow;
 
 namespace Microsoft.ReactNative.Managed.CodeGen
 {
-    /// <summary>
-    /// Primary class 
-    /// </summary>
-    public class CodeAnalyzer
+  /// <summary>
+  /// Primary class 
+  /// </summary>
+  public class CodeAnalyzer
+  {
+    public int ConcurrencyLevel { get; set; } = DataflowBlockOptions.Unbounded;
+
+    private readonly CancellationToken m_cancellationToken;
+
+    private readonly ConcurrentBag<SyntaxTree> m_syntaxTrees = new ConcurrentBag<SyntaxTree>();
+    private readonly ConcurrentBag<MetadataReference> m_metadataReferences = new ConcurrentBag<MetadataReference>();
+
+    private Compilation? m_compilation { get; set; }
+
+    private ReactTypes? m_reactTypes;
+    internal ReactTypes ReactTypes
     {
-        public int ConcurrencyLevel { get; set; } = DataflowBlockOptions.Unbounded;
+      get
+      {
+        Contract.Assert(m_reactTypes != null);
+        return m_reactTypes;
+      }
+    }
 
-        private readonly CancellationToken m_cancellationToken;
 
-        private readonly ConcurrentBag<SyntaxTree> m_syntaxTrees = new ConcurrentBag<SyntaxTree>();
-        private readonly ConcurrentBag<MetadataReference> m_metadataReferences = new ConcurrentBag<MetadataReference>();
+    private readonly List<Diagnostic> m_diagnostics = new List<Diagnostic>();
+    public IEnumerable<Diagnostic> Diagnostics => m_diagnostics;
 
-        private Compilation? m_compilation { get; set; }
+    public CodeAnalyzer(CancellationToken cancellationToken)
+    {
+      m_cancellationToken = cancellationToken;
+    }
 
-        private ReactTypes? m_reactTypes;
-        internal ReactTypes ReactTypes
+    internal void AddSyntaxTree(SyntaxTree syntaxTree)
+    {
+      m_syntaxTrees.Add(syntaxTree);
+    }
+
+    public async Task ParseSourceFilesAsync(IEnumerable<string> sourceFiles, IEnumerable<string>? preprocessorSymbols)
+    {
+      var csharpParseOptions = new CSharpParseOptions(
+        preprocessorSymbols: preprocessorSymbols,
+        languageVersion: LanguageVersion.Latest);
+
+      var block = new ActionBlock<string>(async file =>
+      {
+        string text = await File.ReadAllTextAsync(file, m_cancellationToken);
+        AddSyntaxTree(CSharpSyntaxTree.ParseText(text, path: file, options: csharpParseOptions));
+      },
+      new ExecutionDataflowBlockOptions()
+      {
+        MaxDegreeOfParallelism = ConcurrencyLevel,
+        CancellationToken = m_cancellationToken,
+      });
+      foreach (var sourceFile in sourceFiles)
+      {
+        block.Post(sourceFile);
+      }
+
+      block.Complete();
+      await block.Completion;
+    }
+
+    public async Task LoadMetadataReferencesAsync(IEnumerable<string> references)
+    {
+      var block = new ActionBlock<string>(file =>
         {
-            get
-            {
-                Contract.Assert(m_reactTypes != null);
-                return m_reactTypes;
-            }
-        }
+          m_metadataReferences.Add(MetadataReference.CreateFromFile(file));
+        },
+        new ExecutionDataflowBlockOptions()
+        {
+          MaxDegreeOfParallelism = ConcurrencyLevel,
+          CancellationToken = m_cancellationToken,
+        });
+      foreach (var reference in references.Distinct())
+      {
+        block.Post(reference);
+      }
+
+      block.Complete();
+      await block.Completion;
+    }
 
+    public bool TryCompileAndCheckForErrors()
+    {
+      Contract.Assert(m_syntaxTrees.Any(), "Expected to have syntax trees loaded");
+      Contract.Assert(m_metadataReferences.Any(), "Expected to have references loaded");
+
+      m_compilation = CSharpCompilation.Create(
+        "temp",
+        m_syntaxTrees,
+        m_metadataReferences,
+        new CSharpCompilationOptions(OutputKind.WindowsRuntimeMetadata)
+      );
+
+      Contract.Assert(m_compilation != null, "Expect Microsoft.Net.Compilers to always return a compilation unit.");
+
+      m_diagnostics.AddRange(m_compilation
+        .GetDiagnostics(m_cancellationToken)
+        .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
+        );
+      if (m_diagnostics.Count > 0)
+      {
+        return false;
+      }
+
+      return ReactTypes.TryLoad(m_compilation, m_diagnostics, out m_reactTypes);
+    }
 
-        private readonly List<Diagnostic> m_diagnostics = new List<Diagnostic>();
-        public IEnumerable<Diagnostic> Diagnostics => m_diagnostics;
+    internal IEnumerable<INamedTypeSymbol> GetAllTypes()
+    {
+      Contract.Assert(m_compilation != null, "Expected to have a compilation. Must call CompileAndCheckForErrors first");
+
+      var allTypes = new List<INamedTypeSymbol>();
+      CollectTypes(m_compilation.Assembly.GlobalNamespace, allTypes);
+      return allTypes;
+    }
+
+    public ReactAssembly AnalyzeAndConstructAssemblyModel()
+    {
+      Contract.Assert(m_compilation != null, "Expected to have a compilation. Must call CompileAndCheckForErrors first");
 
-        public CodeAnalyzer(CancellationToken cancellationToken)
+      var assembly = new ReactAssembly();
+      var processedTypes = new HashSet<ITypeSymbol>(SymbolEqualityComparer.Default);
+
+      foreach (var type in GetAllTypes())
+      {
+        if (TryExtractModule(type, out var module))
         {
-            m_cancellationToken = cancellationToken;
+          assembly.Modules.Add(module);
         }
 
-        internal void AddSyntaxTree(SyntaxTree syntaxTree)
+        if (IsViewManager(type))
         {
-            m_syntaxTrees.Add(syntaxTree);
+          assembly.ViewManagers.Add(type);
         }
 
-        public async Task ParseSourceFilesAsync(IEnumerable<string> sourceFiles, IEnumerable<string>? preprocessorSymbols)
+        // Proactively register serializable types.
+        switch (type.TypeKind)
         {
-            var csharpParseOptions = new CSharpParseOptions(
-              preprocessorSymbols: preprocessorSymbols,
-              languageVersion: LanguageVersion.Latest);
-
-            var block = new ActionBlock<string>(async file =>
-            {
-                string text = await File.ReadAllTextAsync(file, m_cancellationToken);
-                AddSyntaxTree(CSharpSyntaxTree.ParseText(text, path: file, options: csharpParseOptions));
-            },
-            new ExecutionDataflowBlockOptions()
-            {
-                MaxDegreeOfParallelism = ConcurrencyLevel,
-                CancellationToken = m_cancellationToken,
-            });
-            foreach (var sourceFile in sourceFiles)
-            {
-                block.Post(sourceFile);
-            }
-
-            block.Complete();
-            await block.Completion;
+          case TypeKind.Enum:
+            assembly.SerializableTypes.Add(type, type.TypeKind);
+            break;
         }
 
-        public async Task LoadMetadataReferencesAsync(IEnumerable<string> references)
+        // Register extension methods
+        if (type.MightContainExtensionMethods)
         {
-            var block = new ActionBlock<string>(file =>
-              {
-                  m_metadataReferences.Add(MetadataReference.CreateFromFile(file));
-              },
-              new ExecutionDataflowBlockOptions()
-              {
-                  MaxDegreeOfParallelism = ConcurrencyLevel,
-                  CancellationToken = m_cancellationToken,
-              });
-            foreach (var reference in references.Distinct())
+          foreach (var member in type.GetMembers())
+          {
+            if (member is IMethodSymbol method)
             {
-                block.Post(reference);
+              if (method.IsExtensionMethod &&
+                  method.Parameters.Length == 2 &&
+                  !(method.Parameters[1].Type is ITypeParameterSymbol))
+              {
+                if (method.Parameters[0].Type.Equals(ReactTypes.JSValueReader, SymbolEqualityComparer.Default) &&
+                    method.Parameters[1].RefKind == RefKind.Out)
+                {
+                  assembly.JSReaderFunctions.Add(method.Parameters[1].Type, method);
+                }
+                else if (method.Parameters[0].Type.Equals(ReactTypes.JSValueWriter, SymbolEqualityComparer.Default))
+                {
+                  assembly.JSWriterFunctions.Add(method.Parameters[1].Type, method);
+                }
+              }
             }
-
-            block.Complete();
-            await block.Completion;
+          }
         }
+      }
 
-        public bool TryCompileAndCheckForErrors()
+      foreach (var module in assembly.Modules)
+      {
+        foreach (var method in module.Methods)
         {
-            Contract.Assert(m_syntaxTrees.Any(), "Expected to have syntax trees loaded");
-            Contract.Assert(m_metadataReferences.Any(), "Expected to have references loaded");
-
-            m_compilation = CSharpCompilation.Create(
-              "temp",
-              m_syntaxTrees,
-              m_metadataReferences,
-              new CSharpCompilationOptions(OutputKind.WindowsRuntimeMetadata)
-            );
-
-            Contract.Assert(m_compilation != null, "Expect Microsoft.Net.Compilers to always return a compilation unit.");
-
-            m_diagnostics.AddRange(m_compilation
-              .GetDiagnostics(m_cancellationToken)
-              .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
-              );
-            if (m_diagnostics.Count > 0)
-            {
-                return false;
-            }
-
-            return ReactTypes.TryLoad(m_compilation, m_diagnostics, out m_reactTypes);
+          AddSerializableMethod(method.Method);
         }
 
-        internal IEnumerable<INamedTypeSymbol> GetAllTypes()
+        foreach (var getConstants in module.GetConstants)
         {
-            Contract.Assert(m_compilation != null, "Expected to have a compilation. Must call CompileAndCheckForErrors first");
-
-            var allTypes = new List<INamedTypeSymbol>();
-            CollectTypes(m_compilation.Assembly.GlobalNamespace, allTypes);
-            return allTypes;
+          AddSerializableType(getConstants.Method.ReturnType);
         }
 
-        public ReactAssembly AnalyzeAndConstructAssemblyModel()
+        foreach (var constant in module.Constants)
         {
-            Contract.Assert(m_compilation != null, "Expected to have a compilation. Must call CompileAndCheckForErrors first");
-
-            var assembly = new ReactAssembly();
-            var proceseedTypes = new HashSet<ITypeSymbol>();
+          if (constant.Symbol is IFieldSymbol field)
+          {
+            AddSerializableType(field.Type);
+          }
+          else if (constant.Symbol is IPropertySymbol property)
+          {
+            AddSerializableType(property.Type);
+          }
+        }
 
-            foreach (var type in GetAllTypes())
-            {
-                if (TryExtractModule(type, out var module))
-                {
-                    assembly.Modules.Add(module);
-                }
+        foreach (var callback in module.Events.Union<ReactCallback>(module.Functions))
+        {
+          foreach (var param in callback.CallbackParameters)
+          {
+            AddSerializableType(param.Type);
+          }
+        }
+      }
 
-                if (IsViewManager(type))
-                {
-                    assembly.ViewManagers.Add(type);
-                }
+      void AddSerializableMethod(IMethodSymbol method)
+      {
+        AddSerializableType(method.ReturnType);
+        foreach (var param in method.Parameters)
+        {
+          AddSerializableType(param.Type);
+        }
+      }
 
-                // Proactively register serializable types.
-                switch (type.TypeKind)
-                {
-                    case TypeKind.Enum:
-                        assembly.SerializableTypes.Add(type, type.TypeKind);
-                        break;
-                }
+      void AddSerializableType(ITypeSymbol type)
+      {
+        if (processedTypes.Contains(type))
+        {
+          return;
+        }
 
-                // Register extension methods
-                if (type.MightContainExtensionMethods)
-                {
-                    foreach (var member in type.GetMembers())
-                    {
-                        if (member is IMethodSymbol method)
-                        {
-                            if (method.IsExtensionMethod &&
-                                method.Parameters.Length == 2 &&
-                                !(method.Parameters[1].Type is ITypeParameterSymbol))
-                            {
-                                if (method.Parameters[0].Type.Equals(ReactTypes.JSValueReader, SymbolEqualityComparer.Default) &&
-                                    method.Parameters[1].RefKind == RefKind.Out)
-                                {
-                                    assembly.JSReaderFunctions.Add(method.Parameters[1].Type, method);
-                                }
-                                else if (method.Parameters[0].Type.Equals(ReactTypes.JSValueWriter, SymbolEqualityComparer.Default))
-                                {
-                                    assembly.JSWriterFunctions.Add(method.Parameters[1].Type, method);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+        processedTypes.Add(type);
 
-            foreach (var module in assembly.Modules)
+        if (type is INamedTypeSymbol namedType)
+        {
+          if (type.TypeKind == TypeKind.Delegate)
+          {
+            Contract.Assert(namedType.DelegateInvokeMethod != null);
+
+            AddSerializableMethod(namedType.DelegateInvokeMethod);
+          }
+          else if (type.ContainingAssembly.Equals(m_compilation.Assembly, SymbolEqualityComparer.Default))
+          {
+            if (namedType.TypeKind == TypeKind.Class)
             {
-                foreach (var method in module.Methods)
-                {
-                    AddSerializableMethod(method.Method);
-                }
-
-                foreach (var constant in module.Constants)
-                {
-                    if (constant.Symbol is IFieldSymbol field)
-                    {
-                        AddSerializableType(field.Type);
-                    }
-                    else if (constant.Symbol is IPropertySymbol property)
-                    {
-                        AddSerializableType(property.Type);
-                    }
-                }
+              // Check that classes have a default constructor.
+              if (!namedType
+                .GetMembers()
+                .Any(member =>
+                  member is IMethodSymbol method &&
+                  method.MethodKind == MethodKind.Constructor &&
+                  method.Parameters.Length == 0))
+              {
 
-                foreach (var callback in module.Events.Union<ReactCallback>(module.Functions))
-                {
-                    foreach (var param in callback.CallbackParameters)
-                    {
-                        AddSerializableType(param.Type);
-                    }
-                }
+              }
             }
 
-            void AddSerializableMethod(IMethodSymbol method)
-            {
-                AddSerializableType(method.ReturnType);
-                foreach (var param in method.Parameters)
-                {
-                    AddSerializableType(param.Type);
-                }
-            }
+            assembly.SerializableTypes.Add(namedType, namedType.TypeKind);
+          }
+        }
+      }
 
-            void AddSerializableType(ITypeSymbol type)
-            {
-                if (proceseedTypes.Contains(type))
-                {
-                    return;
-                }
+      return assembly;
+    }
 
-                proceseedTypes.Add(type);
+    internal bool IsViewManager(INamedTypeSymbol type)
+    {
+      return !type.IsAbstract && type.AllInterfaces.Any(iface => iface.Equals(ReactTypes.IViewManagerType, SymbolEqualityComparer.Default));
+    }
 
-                if (type is INamedTypeSymbol namedType)
-                {
-                    if (type.TypeKind == TypeKind.Delegate)
-                    {
-                        Contract.Assert(namedType.DelegateInvokeMethod != null);
-
-                        AddSerializableMethod(namedType.DelegateInvokeMethod);
-                    }
-                    else if (type.ContainingAssembly.Equals(m_compilation.Assembly, SymbolEqualityComparer.Default))
-                    {
-                        if (namedType.TypeKind == TypeKind.Class)
-                        {
-                            // Check that classes have a default constructor.
-                            if (!namedType
-                              .GetMembers()
-                              .Any(member =>
-                                member is IMethodSymbol method &&
-                                method.MethodKind == MethodKind.Constructor &&
-                                method.Parameters.Length == 0))
-                            {
-
-                            }
-                        }
-
-                        assembly.SerializableTypes.Add(namedType, namedType.TypeKind);
-                    }
-                }
-            }
+    internal bool TryExtractModule(INamedTypeSymbol type, [NotNullWhen(returnValue: true)] out ReactModule? module)
+    {
+      if (TryFindAttribute(type, ReactTypes.ReactModuleAttribute, out var attr))
+      {
+        string? moduleName = null;
+        string? eventEmitterName = null;
 
-            return assembly;
+        if (attr.ConstructorArguments.Length > 0)
+        {
+          moduleName = attr.ConstructorArguments[0].Value as string;
         }
 
-        internal bool IsViewManager(INamedTypeSymbol type)
+        foreach (var namedArgument in attr.NamedArguments)
         {
-            return !type.IsAbstract && type.AllInterfaces.Any(iface => iface.Equals(ReactTypes.IViewManagerType, SymbolEqualityComparer.Default));
+          switch (namedArgument.Key)
+          {
+            case nameof(ReactModuleAttribute.ModuleName):
+              moduleName = namedArgument.Value.Value as string;
+              break;
+            case nameof(ReactModuleAttribute.EventEmitterName):
+              eventEmitterName = namedArgument.Value.Value as string;
+              break;
+            default:
+              var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
+              m_diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.UnexpectedPropertyInAttribute, location ?? Location.None, namedArgument.Key, attr.AttributeClass?.Name));
+              module = null;
+              return false;
+          }
         }
 
-        internal bool TryExtractModule(INamedTypeSymbol type, [NotNullWhen(returnValue: true)] out ReactModule? module)
-        {
-            if (TryFindAttribute(type, ReactTypes.ReactModuleAttribute, out var attr))
-            {
-                string? moduleName = null;
-                string? eventEmitterName = null;
+        moduleName ??= type.Name;
+        eventEmitterName ??= ReactNativeNames.DefaultEventEmitterName;
 
-                if (attr.ConstructorArguments.Length > 0)
-                {
-                    moduleName = attr.ConstructorArguments[0].Value as string;
-                }
+        module = new ReactModule(type, moduleName, eventEmitterName);
 
-                foreach (var namedArgument in attr.NamedArguments)
-                {
-                    switch (namedArgument.Key)
-                    {
-                        case nameof(ReactModuleAttribute.ModuleName):
-                            moduleName = namedArgument.Value.Value as string;
-                            break;
-                        case nameof(ReactModuleAttribute.EventEmitterName):
-                            eventEmitterName = namedArgument.Value.Value as string;
-                            break;
-                        default:
-                            var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
-                            m_diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.UnexpectedPropertyInAttribute, location ?? Location.None, namedArgument.Key, attr.AttributeClass?.Name));
-                            module = null;
-                            return false;
-                    }
-                }
+        foreach (var member in type.GetMembers())
+        {
+          if (member is IMethodSymbol method)
+          {
+            if (TryExtractMethod(method, out var asyncMethod))
+            {
+              module.Methods.Add(asyncMethod);
+            }
+            else if (TryExtractSyncMethod(method, out var syncMethod))
+            {
+              module.Methods.Add(syncMethod);
+            }
+            else if (TryExtractInitializer(method, out var initializer))
+            {
+              module.Initializers.Add(initializer);
+            }
+            else if (TryExtractConstantProvider(method, out var constantProvider))
+            {
+              module.ConstantProviders.Add(constantProvider);
+            }
+            else if (TryExtractGetConstants(method, out var getConstants))
+            {
+              module.GetConstants.Add(getConstants);
+            }
+          }
+          else if (member is IPropertySymbol || member is IFieldSymbol)
+          {
+            if (TryExtractConstant(member, out var constant))
+            {
+              module.Constants.Add(constant);
+            }
+            else if (TryExtractEvent(member, eventEmitterName, out var evnt))
+            {
+              module.Events.Add(evnt);
+            }
+            else if (TryExtractFunction(member, moduleName, out var function))
+            {
+              module.Functions.Add(function);
+            }
+          }
+        }
 
-                moduleName ??= type.Name;
-                eventEmitterName ??= ReactNativeNames.DefaultEventEmitterName;
+        return true;
+      }
 
-                module = new ReactModule(type, moduleName, eventEmitterName);
+      module = null;
+      return false;
+    }
 
-                foreach (var member in type.GetMembers())
-                {
-                    if (member is IMethodSymbol method)
-                    {
-                        if (TryExtractMethod(method, out var asyncMethod))
-                        {
-                            module.Methods.Add(asyncMethod);
-                        }
-                        else if (TryExtractSyncMethod(method, out var syncMethod))
-                        {
-                            module.Methods.Add(syncMethod);
-                        }
-                        else if (TryExtractInitializer(method, out var initializer))
-                        {
-                            module.Initializers.Add(initializer);
-                        }
-                        else if (TryExtractConstantProvider(method, out var constantProvider))
-                        {
-                            module.ConstantProviders.Add(constantProvider);
-                        }
-                    }
-                    else if (member is IPropertySymbol || member is IFieldSymbol)
-                    {
-                        if (TryExtractConstant(member, out var constant))
-                        {
-                            module.Constants.Add(constant);
-                        }
-                        else if (TryExtractEvent(member, eventEmitterName, out var evnt))
-                        {
-                            module.Events.Add(evnt);
-                        }
-                        else if (TryExtractFunction(member, moduleName, out var function))
-                        {
-                            module.Functions.Add(function);
-                        }
-                    }
-                }
+    private bool TryExtractMethod(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactMethod? reactMethod)
+    {
+      return TryExtractMethodFromAttributeData(method, ReactTypes.ReactMethodAttribute, synchronous: false, out reactMethod);
+    }
 
-                return true;
-            }
+    private bool TryExtractSyncMethod(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactMethod? reactMethod)
+    {
+      return TryExtractMethodFromAttributeData(method, ReactTypes.ReactSyncMethodAttribute, synchronous: true, out reactMethod);
+    }
 
-            module = null;
-            return false;
-        }
+    private bool TryExtractMethodFromAttributeData(
+      IMethodSymbol method,
+      INamedTypeSymbol attributeType,
+      bool synchronous,
+      [NotNullWhen(returnValue: true)] out ReactMethod? reactMethod)
+    {
+      Contract.Requires(m_reactTypes != null);
 
-        private bool TryExtractMethod(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactMethod? reactMethod)
+      if (TryFindAttribute(method, attributeType, out var attr))
+      {
+        string? name = null;
+        if (attr.ConstructorArguments.Length > 0)
         {
-            return TryExtractMethodFromAttributeData(method, ReactTypes.ReactMethodAttribute, synchronous: false, out reactMethod);
+          name = attr.ConstructorArguments[0].Value as string;
         }
 
-        private bool TryExtractSyncMethod(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactMethod? reactMethod)
+        foreach (var namedArgument in attr.NamedArguments)
         {
-            return TryExtractMethodFromAttributeData(method, ReactTypes.ReactSyncMethodAttribute, synchronous: true, out reactMethod);
+          switch (namedArgument.Key)
+          {
+            case nameof(ReactMethodAttribute.MethodName):
+              name = namedArgument.Value.Value as string;
+              break;
+            default:
+              var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
+              m_diagnostics.Add(Diagnostic.Create(
+                DiagnosticDescriptors.UnexpectedPropertyInAttribute,
+                location ?? Location.None,
+                namedArgument.Key,
+                attr.AttributeClass?.Name));
+              reactMethod = null;
+              return false;
+          }
         }
 
-        private bool TryExtractMethodFromAttributeData(
-          IMethodSymbol method,
-          INamedTypeSymbol attributeType,
-          bool synchronous,
-          [NotNullWhen(returnValue: true)] out ReactMethod? reactMethod)
-        {
-            Contract.Requires(m_reactTypes != null);
+        ReactMethod.MethodReturnStyle? returnStyle = null;
 
-            if (TryFindAttribute(method, attributeType, out var attr))
+        // Compute the effective parameters
+        var effectiveParameters = new List<IParameterSymbol>();
+        ITypeSymbol effectiveReturnType = m_reactTypes.SystemVoid;
+        int resolveParameterCount = 0;
+        int rejectParameterCount = 0;
+        var parameters = method.Parameters;
+        for (int i = 0; i < parameters.Length; ++i)
+        {
+          var param = parameters[i];
+          if (!synchronous) // IsSynchronous methods don't have support for the callbacks
+          {
+            if (i == parameters.Length - 1)
             {
-                string? name = null;
-                if (attr.ConstructorArguments.Length > 0)
-                {
-                    name = attr.ConstructorArguments[0].Value as string;
-                }
-
-                foreach (var namedArgument in attr.NamedArguments)
-                {
-                    switch (namedArgument.Key)
-                    {
-                        case nameof(ReactMethodAttribute.MethodName):
-                            name = namedArgument.Value.Value as string;
-                            break;
-                        default:
-                            var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
-                            m_diagnostics.Add(Diagnostic.Create(
-                              DiagnosticDescriptors.UnexpectedPropertyInAttribute,
-                              location ?? Location.None,
-                              namedArgument.Key,
-                              attr.AttributeClass?.Name));
-                            reactMethod = null;
-                            return false;
-                    }
-                }
-
-                ReactMethod.MethodReturnStyle? returnStyle = null;
-
-                // Compute the effective parameters
-                var effectiveParameters = new List<IParameterSymbol>();
-                ITypeSymbol effectiveReturnType = m_reactTypes.SystemVoid;
-                var parameters = method.Parameters;
-                for (int i = 0; i < parameters.Length; i++)
-                {
-                    var param = parameters[i];
-                    bool skipReadingArg = false;
-
-                    if (!synchronous) // IsSynchronous methods don't have support for the callbacks
-                    {
-                        if (i == parameters.Length - 1)
-                        {
-                            if (IsPromiseType(parameters[i].Type, out var promiseGenericType))
-                            {
-                                returnStyle = ReactMethod.MethodReturnStyle.Promise;
-                                effectiveReturnType = promiseGenericType;
-                                skipReadingArg = true;
-                            }
-
-                            // if the last argument is a callback, assume this is the resolve or resolve function
-                            if (IsSingleArgCallback(parameters[i].Type, out var currentCallBackType))
-                            {
-                                ITypeSymbol? previousCallBackType = null;
-                                var isReject = parameters.Length >= 2 &&
-                                               IsSingleArgCallback(parameters[i - 1].Type, out previousCallBackType);
-                                effectiveReturnType = isReject
-                                  ? previousCallBackType!
-                                  : currentCallBackType!;
-                                returnStyle = isReject
-                                  ? ReactMethod.MethodReturnStyle.TwoCallbacks
-                                  : ReactMethod.MethodReturnStyle.Callback;
-
-                                skipReadingArg = true;
-                            }
-                        }
-                        else if (i == parameters.Length - 2)
-                        {
-                            // if the last 2 argument are callbacks, assume this is the resolve function
-                            if (IsSingleArgCallback(parameters[i].Type, out var resolveCallBackType) &&
-                                IsSingleArgCallback(parameters[i + 1].Type, out _))
-                            {
-                                effectiveReturnType = resolveCallBackType;
-                                returnStyle = ReactMethod.MethodReturnStyle.TwoCallbacks;
-                                skipReadingArg = true;
-                            }
-                        }
-                    }
-
-                    if (!skipReadingArg)
-                    {
-                        effectiveParameters.Add(param);
-                    }
-                }
-
-                if (returnStyle == null)
-                {
-                    if (IsTaskType(method.ReturnType, out var taskReturnType))
-                    {
-                        if (synchronous)
-                        {
-                            m_diagnostics.Add(Diagnostic.Create(
-                              DiagnosticDescriptors.MethodShouldNotReturnTaskWhenSynchronous,
-                              method.GetLocation() ?? Location.None,
-                              method.Name,
-                              attr.AttributeClass?.Name));
-                            reactMethod = null;
-                            return false;
-                        }
-
-                        effectiveReturnType = taskReturnType;
-                        returnStyle = ReactMethod.MethodReturnStyle.Task;
-                    }
-                    else if (method.ReturnsVoid)
-                    {
-                        returnStyle = ReactMethod.MethodReturnStyle.Void;
-                    }
-                    else
-                    {
-                        returnStyle = ReactMethod.MethodReturnStyle.ReturnValue;
-                    }
-                }
-
-                name ??= method.Name;
+              if (IsPromiseType(parameters[i].Type, out var promiseGenericType))
+              {
+                returnStyle = ReactMethod.MethodReturnStyle.Promise;
+                effectiveReturnType = promiseGenericType;
+                break;
+              }
 
-                reactMethod = new ReactMethod(method, name, returnStyle.Value, effectiveReturnType, effectiveParameters, synchronous);
-                return true;
+              // if the last argument is a callback, assume this is the resolve function
+              if (IsCallback(parameters[i].Type, out resolveParameterCount))
+              {
+                returnStyle = ReactMethod.MethodReturnStyle.Callback;
+                break;
+              }
             }
+            else if (i == parameters.Length - 2)
+            {
+              // if the last 2 argument are callbacks, assume these are the resolve and reject functions
+              if (IsCallback(parameters[i].Type, out resolveParameterCount) &&
+                  IsCallback(parameters[i + 1].Type, out rejectParameterCount))
+              {
+                returnStyle = ReactMethod.MethodReturnStyle.TwoCallbacks;
+                break;
+              }
+            }
+          }
 
-            reactMethod = null;
-            return false;
+          effectiveParameters.Add(param);
         }
 
-        private bool TryExtractConstantProvider(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactConstantProvider? constantProvider)
+        if (returnStyle == null)
         {
-            constantProvider = null;
-            if (TryFindAttribute(method, ReactTypes.ReactConstantProviderAttribute, out _))
+          if (IsTaskType(method.ReturnType, out var taskReturnType))
+          {
+            if (synchronous)
             {
-                if (!IsAccessible(method))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.ConstantProviderMustBePublicOrInternal,
-                        method.GetLocation(),
-                        method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        method.Name,
-                        method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        method.DeclaredAccessibility
-                      ));
-                    return false;
-                }
+              m_diagnostics.Add(Diagnostic.Create(
+                DiagnosticDescriptors.MethodShouldNotReturnTaskWhenSynchronous,
+                method.GetLocation() ?? Location.None,
+                method.Name,
+                attr.AttributeClass?.Name));
+              reactMethod = null;
+              return false;
+            }
 
-                if (!method.ReturnsVoid)
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.ConstantProviderMustReturnVoid,
-                        method.GetLocation(),
-                        method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        method.Name,
-                        method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
-                      ));
-                    return false;
-                }
+            effectiveReturnType = taskReturnType;
+            returnStyle = ReactMethod.MethodReturnStyle.Task;
+          }
+          else if (method.ReturnsVoid)
+          {
+            returnStyle = ReactMethod.MethodReturnStyle.Void;
+          }
+          else
+          {
+            returnStyle = ReactMethod.MethodReturnStyle.ReturnValue;
+          }
+        }
 
-                if (method.Parameters.Length != 1 || !method.Parameters[0].Type.Equals(ReactTypes.ReactConstantProvider, SymbolEqualityComparer.Default))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.ConstantProviderMustHaveOneParameterOfTypeReactContext,
-                        method.GetLocation(),
-                        ReactTypes.ReactConstantProvider.ToDisplayParts(SymbolDisplayFormat.FullyQualifiedFormat),
-                        method.Parameters.Length.ToString(CultureInfo.InvariantCulture),
-                        method.Name,
-                        method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
-                      ));
-                    return false;
-                }
+        name ??= method.Name;
 
-                constantProvider = new ReactConstantProvider(method);
-                return true;
-            }
+        reactMethod = new ReactMethod(method, name, returnStyle.Value, effectiveReturnType,
+          effectiveParameters, synchronous, resolveParameterCount, rejectParameterCount);
+        return true;
+      }
 
-            constantProvider = null;
-            return false;
+      reactMethod = null;
+      return false;
+    }
+
+    private bool TryExtractConstantProvider(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactConstantProvider? constantProvider)
+    {
+      constantProvider = null;
+      if (TryFindAttribute(method, ReactTypes.ReactConstantProviderAttribute, out _))
+      {
+        if (!IsAccessible(method))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.ConstantProviderMustBePublicOrInternal,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.DeclaredAccessibility
+            ));
+          return false;
         }
 
-        private bool TryExtractInitializer(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactInitializer? initializer)
+        if (!method.ReturnsVoid)
         {
-            initializer = null;
-            if (TryFindAttribute(method, ReactTypes.ReactInitializerAttribute, out _))
-            {
-                if (!IsAccessible(method))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.InitializersMustBePublicOrInternal,
-                        method.GetLocation(),
-                        method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        method.Name,
-                        method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        method.DeclaredAccessibility
-                      ));
-                    return false;
-                }
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.ConstantProviderMustReturnVoid,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+            ));
+          return false;
+        }
 
-                if (!method.ReturnsVoid)
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.InitializersMustReturnVoid,
-                        method.GetLocation(),
-                        method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        method.Name,
-                        method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
-                        ));
-                    return false;
-                }
+        if (method.Parameters.Length != 1 || !method.Parameters[0].Type.Equals(ReactTypes.ReactConstantProvider, SymbolEqualityComparer.Default))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.ConstantProviderMustHaveOneParameterOfTypeReactContext,
+              method.GetLocation(),
+              ReactTypes.ReactConstantProvider.ToDisplayParts(SymbolDisplayFormat.FullyQualifiedFormat),
+              method.Parameters.Length.ToString(CultureInfo.InvariantCulture),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+            ));
+          return false;
+        }
 
-                if (method.Parameters.Length != 1 || !method.Parameters[0].Type.Equals(ReactTypes.ReactContext, SymbolEqualityComparer.Default))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.InitializersMustHaveOneParameterOfTypeReactContext,
-                        method.GetLocation(),
-                        ReactTypes.ReactContext.ToDisplayParts(SymbolDisplayFormat.FullyQualifiedFormat),
-                        method.Parameters.Length.ToString(CultureInfo.InvariantCulture),
-                        method.Name,
-                        method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
-                      ));
-                    return false;
-                }
+        constantProvider = new ReactConstantProvider(method);
+        return true;
+      }
 
-                initializer = new ReactInitializer(method);
-                return true;
-            }
+      constantProvider = null;
+      return false;
+    }
 
-            return false;
+    private bool TryExtractGetConstants(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactGetConstants? getConstants)
+    {
+      getConstants = null;
+      if (TryFindAttribute(method, ReactTypes.ReactGetConstantsAttribute, out _))
+      {
+        if (!IsAccessible(method))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.GetConstantsMustBePublicOrInternal,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.DeclaredAccessibility
+            ));
+          return false;
         }
 
-        private bool TryExtractConstant(ISymbol symbol, [NotNullWhen(returnValue: true)] out ReactConstant? constant)
+        if (method.ReturnsVoid)
         {
-            if (TryFindAttribute(symbol, ReactTypes.ReactConstantAttribute, out var attr))
-            {
-                string? name = null;
-                if (attr.ConstructorArguments.Length > 0)
-                {
-                    name = attr.ConstructorArguments[0].Value as string;
-                }
-
-                foreach (var namedArgument in attr.NamedArguments)
-                {
-                    switch (namedArgument.Key)
-                    {
-                        case nameof(ReactConstantAttribute.ConstantName):
-                            name = namedArgument.Value.Value as string;
-                            break;
-                        default:
-                            var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
-                            m_diagnostics.Add(Diagnostic.Create(
-                              DiagnosticDescriptors.UnexpectedPropertyInAttribute,
-                              location ?? Location.None,
-                              namedArgument.Key,
-                              attr.AttributeClass?.Name));
-                            constant = null;
-                            return false;
-                    }
-                }
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.GetConstantsMustNotReturnVoid,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+            ));
+          return false;
+        }
 
-                name ??= symbol.Name;
+        if (method.ReturnType.SpecialType != SpecialType.None
+          || (method.ReturnType.TypeKind != TypeKind.Struct && method.ReturnType.TypeKind != TypeKind.Class))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.GetConstantsMustReturnStructOrClass,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+            ));
+          return false;
+        }
 
-                if (!IsAccessible(symbol))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.ConstantsMustBePublicOrInternal,
-                        symbol.GetLocation(),
-                        symbol.Name,
-                        symbol.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        symbol.DeclaredAccessibility
-                      ));
-                    constant = null;
-                    return false;
-                }
+        if (method.Parameters.Length != 0)
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.GetConstantsMustNotHaveParameters,
+              method.GetLocation(),
+              method.Parameters.Length.ToString(CultureInfo.InvariantCulture),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+            ));
+          return false;
+        }
 
-                if (symbol is IPropertySymbol property && (property.GetMethod == null || !IsAccessible(property.GetMethod)))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.ConstantsMustBeGettable,
-                        symbol.GetLocation(),
-                        property.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
-                    constant = null;
-                    return false;
-                }
+        getConstants = new ReactGetConstants(method);
+      }
 
-                constant = new ReactConstant(symbol, name);
-                return true;
-            }
+      return getConstants != null;
+    }
 
-            constant = null;
-            return false;
+    private bool TryExtractInitializer(IMethodSymbol method, [NotNullWhen(returnValue: true)] out ReactInitializer? initializer)
+    {
+      initializer = null;
+      if (TryFindAttribute(method, ReactTypes.ReactInitializerAttribute, out _))
+      {
+        if (!IsAccessible(method))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.InitializersMustBePublicOrInternal,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.DeclaredAccessibility
+            ));
+          return false;
         }
 
-        private bool TryExtractEvent(ISymbol symbol, string defaultEventEmitterName, [NotNullWhen(returnValue: true)] out ReactEvent? reactEvent)
+        if (!method.ReturnsVoid)
         {
-            if (TryExtractCallback(symbol, defaultEventEmitterName, ReactTypes.ReactEventAttribute, out var callbackParameters, out var name, out var declaredModuleName))
-            {
-                reactEvent = new ReactEvent(symbol, callbackParameters, name, declaredModuleName);
-                return true;
-            }
-
-            reactEvent = null;
-            return false;
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.InitializersMustReturnVoid,
+              method.GetLocation(),
+              method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+              ));
+          return false;
         }
 
-        private bool TryExtractFunction(ISymbol symbol, string moduleName, [NotNullWhen(returnValue: true)] out ReactFunction? function)
+        if (method.Parameters.Length != 1 || !method.Parameters[0].Type.Equals(ReactTypes.ReactContext, SymbolEqualityComparer.Default))
         {
-            if (TryExtractCallback(symbol, moduleName, ReactTypes.ReactFunctionAttribute, out var callbackParameters, out var name, out var declaredModuleName))
-            {
-                function = new ReactFunction(symbol, callbackParameters, name, declaredModuleName);
-                return true;
-            }
-
-            function = null;
-            return false;
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.InitializersMustHaveOneParameterOfTypeReactContext,
+              method.GetLocation(),
+              ReactTypes.ReactContext.ToDisplayParts(SymbolDisplayFormat.FullyQualifiedFormat),
+              method.Parameters.Length.ToString(CultureInfo.InvariantCulture),
+              method.Name,
+              method.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)
+            ));
+          return false;
         }
 
-        private bool TryExtractCallback(
-          ISymbol symbol,
-          string defaultCallbackContextName,
-          INamedTypeSymbol attribute,
-          out ImmutableArray<IParameterSymbol> callbackParameters,
-          [NotNullWhen(returnValue: true)] out string? name,
-          [NotNullWhen(returnValue: true)] out string? callbackContextName)
+        initializer = new ReactInitializer(method);
+        return true;
+      }
+
+      return false;
+    }
+
+    private bool TryExtractConstant(ISymbol symbol, [NotNullWhen(returnValue: true)] out ReactConstant? constant)
+    {
+      if (TryFindAttribute(symbol, ReactTypes.ReactConstantAttribute, out var attr))
+      {
+        string? name = null;
+        if (attr.ConstructorArguments.Length > 0)
         {
-            callbackParameters = default;
-            name = null;
-            callbackContextName = null;
+          name = attr.ConstructorArguments[0].Value as string;
+        }
 
-            if (TryFindAttribute(symbol, attribute, out var attr))
-            {
-                name = null;
-                callbackContextName = null;
-                if (attr.ConstructorArguments.Length > 0)
-                {
-                    name = attr.ConstructorArguments[0].Value as string;
-                }
+        foreach (var namedArgument in attr.NamedArguments)
+        {
+          switch (namedArgument.Key)
+          {
+            case nameof(ReactConstantAttribute.ConstantName):
+              name = namedArgument.Value.Value as string;
+              break;
+            default:
+              var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
+              m_diagnostics.Add(Diagnostic.Create(
+                DiagnosticDescriptors.UnexpectedPropertyInAttribute,
+                location ?? Location.None,
+                namedArgument.Key,
+                attr.AttributeClass?.Name));
+              constant = null;
+              return false;
+          }
+        }
 
-                foreach (var namedArgument in attr.NamedArguments)
-                {
-                    switch (namedArgument.Key)
-                    {
-                        case nameof(ReactFunctionAttribute.FunctionName):
-                        case nameof(ReactEventAttribute.EventName):
-                            name = namedArgument.Value.Value as string;
-                            break;
-                        case nameof(ReactFunctionAttribute.ModuleName):
-                        case nameof(ReactEventAttribute.EventEmitterName):
-                            callbackContextName = namedArgument.Value.Value as string;
-                            break;
-                        default:
-                            var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
-                            m_diagnostics.Add(Diagnostic.Create(
-                              DiagnosticDescriptors.UnexpectedPropertyInAttribute,
-                              location ?? Location.None,
-                              namedArgument.Key,
-                              attr.AttributeClass?.Name));
-                            return false;
-                    }
-                }
+        name ??= symbol.Name;
 
-                ITypeSymbol? type = null;
-                switch (symbol)
-                {
-                    case IPropertySymbol property:
-                        type = property.Type;
-
-                        if (property.SetMethod == null || !IsAccessible(property.SetMethod))
-                        {
-                            m_diagnostics.Add(
-                              Diagnostic.Create(DiagnosticDescriptors.CallbacksMustBeSettable,
-                                symbol.GetLocation(),
-                                property.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                                symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
-                            return false;
-                        }
-
-                        break;
-                    case IFieldSymbol field:
-                        type = field.Type;
-                        break;
-                    default:
-                        throw Contract.AssertFailure("Unsupported symbol");
-                }
+        if (!IsAccessible(symbol))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.ConstantsMustBePublicOrInternal,
+              symbol.GetLocation(),
+              symbol.Name,
+              symbol.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              symbol.DeclaredAccessibility
+            ));
+          constant = null;
+          return false;
+        }
 
-                if (!IsAccessible(symbol))
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.CallbackMustBePublicOrInternal,
-                        symbol.GetLocation(),
-                        symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat),
-                        symbol.DeclaredAccessibility));
-                    return false;
-                }
+        if (symbol is IPropertySymbol property && (property.GetMethod == null || !IsAccessible(property.GetMethod)))
+        {
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.ConstantsMustBeGettable,
+              symbol.GetLocation(),
+              property.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
+          constant = null;
+          return false;
+        }
 
-                if (!(type is INamedTypeSymbol namedType) || namedType.DelegateInvokeMethod == null)
-                {
-                    m_diagnostics.Add(
-                      Diagnostic.Create(DiagnosticDescriptors.CallbackTypeMustBeDelegate,
-                        symbol.GetLocation(),
-                        type.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                        symbol.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
-                    return false;
-                }
+        constant = new ReactConstant(symbol, name);
+        return true;
+      }
 
-                if (!namedType.DelegateInvokeMethod.ReturnsVoid)
-                {
-                    var location = symbol.Locations.FirstOrDefault();
-                    m_diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.CallbackDelegateMustReturnVoid, location,
-                      symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                      symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat),
-                      namedType.DelegateInvokeMethod.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
-                    return false;
-                }
+      constant = null;
+      return false;
+    }
 
-                name ??= symbol.Name;
-                callbackContextName ??= defaultCallbackContextName;
-                callbackParameters = namedType.DelegateInvokeMethod.Parameters;
+    private bool TryExtractEvent(ISymbol symbol, string defaultEventEmitterName, [NotNullWhen(returnValue: true)] out ReactEvent? reactEvent)
+    {
+      if (TryExtractCallback(symbol, defaultEventEmitterName, ReactTypes.ReactEventAttribute, out var callbackParameters, out var name, out var declaredModuleName))
+      {
+        reactEvent = new ReactEvent(symbol, callbackParameters, name, declaredModuleName);
+        return true;
+      }
+
+      reactEvent = null;
+      return false;
+    }
 
-                return true;
-            }
+    private bool TryExtractFunction(ISymbol symbol, string moduleName, [NotNullWhen(returnValue: true)] out ReactFunction? function)
+    {
+      if (TryExtractCallback(symbol, moduleName, ReactTypes.ReactFunctionAttribute, out var callbackParameters, out var name, out var declaredModuleName))
+      {
+        function = new ReactFunction(symbol, callbackParameters, name, declaredModuleName);
+        return true;
+      }
+
+      function = null;
+      return false;
+    }
 
-            return false;
+    private bool TryExtractCallback(
+      ISymbol symbol,
+      string defaultCallbackContextName,
+      INamedTypeSymbol attribute,
+      out ImmutableArray<IParameterSymbol> callbackParameters,
+      [NotNullWhen(returnValue: true)] out string? name,
+      [NotNullWhen(returnValue: true)] out string? callbackContextName)
+    {
+      callbackParameters = default;
+      name = null;
+      callbackContextName = null;
+
+      if (TryFindAttribute(symbol, attribute, out var attr))
+      {
+        name = null;
+        callbackContextName = null;
+        if (attr.ConstructorArguments.Length > 0)
+        {
+          name = attr.ConstructorArguments[0].Value as string;
         }
 
-        private static void CollectTypes(INamespaceSymbol namespaceSymbol, ICollection<INamedTypeSymbol> result)
+        foreach (var namedArgument in attr.NamedArguments)
         {
-            foreach (var type in namespaceSymbol.GetTypeMembers())
-            {
-                CollectTypes(type, result);
-            }
-
-            foreach (var childNs in namespaceSymbol.GetNamespaceMembers())
-            {
-                CollectTypes(childNs, result);
-            }
+          switch (namedArgument.Key)
+          {
+            case nameof(ReactFunctionAttribute.FunctionName):
+            case nameof(ReactEventAttribute.EventName):
+              name = namedArgument.Value.Value as string;
+              break;
+            case nameof(ReactFunctionAttribute.ModuleName):
+            case nameof(ReactEventAttribute.EventEmitterName):
+              callbackContextName = namedArgument.Value.Value as string;
+              break;
+            default:
+              var location = attr.ApplicationSyntaxReference?.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);
+              m_diagnostics.Add(Diagnostic.Create(
+                DiagnosticDescriptors.UnexpectedPropertyInAttribute,
+                location ?? Location.None,
+                namedArgument.Key,
+                attr.AttributeClass?.Name));
+              return false;
+          }
         }
 
-        private static void CollectTypes(INamedTypeSymbol type, ICollection<INamedTypeSymbol> result)
+        ITypeSymbol? type = null;
+        switch (symbol)
         {
-            result.Add(type);
+          case IPropertySymbol property:
+            type = property.Type;
 
-            foreach (var nested in type.GetTypeMembers())
+            if (property.SetMethod == null || !IsAccessible(property.SetMethod))
             {
-                CollectTypes(nested, result);
+              m_diagnostics.Add(
+                Diagnostic.Create(DiagnosticDescriptors.CallbacksMustBeSettable,
+                  symbol.GetLocation(),
+                  property.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+                  symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
+              return false;
             }
+
+            break;
+          case IFieldSymbol field:
+            type = field.Type;
+            break;
+          default:
+            throw Contract.AssertFailure("Unsupported symbol");
         }
 
-        private bool TryFindAttribute(ISymbol symbol, INamedTypeSymbol attributeType, out AttributeData attr)
+        if (!IsAccessible(symbol))
         {
-            attr = symbol.GetAttributes().FirstOrDefault(potentialMatch => potentialMatch.AttributeClass != null && potentialMatch.AttributeClass.Equals(attributeType, SymbolEqualityComparer.Default));
-            return attr != null;
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.CallbackMustBePublicOrInternal,
+              symbol.GetLocation(),
+              symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat),
+              symbol.DeclaredAccessibility));
+          return false;
         }
 
-        private bool IsAccessible(ISymbol symbol)
+        if (!(type is INamedTypeSymbol namedType) || namedType.DelegateInvokeMethod == null)
         {
-            return symbol.DeclaredAccessibility == Accessibility.Public ||
-                   symbol.DeclaredAccessibility == Accessibility.Internal;
+          m_diagnostics.Add(
+            Diagnostic.Create(DiagnosticDescriptors.CallbackTypeMustBeDelegate,
+              symbol.GetLocation(),
+              type.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+              symbol.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
+          return false;
         }
 
-        private bool IsPromiseType(ITypeSymbol type, [NotNullWhen(returnValue: true)] out ITypeSymbol? typeParameter)
+        if (!namedType.DelegateInvokeMethod.ReturnsVoid)
         {
-            Contract.Requires(m_reactTypes != null);
+          var location = symbol.Locations.FirstOrDefault();
+          m_diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.CallbackDelegateMustReturnVoid, location,
+            symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+            symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat),
+            namedType.DelegateInvokeMethod.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat)));
+          return false;
+        }
 
-            if (type != null &&
-                type is INamedTypeSymbol namedType &&
-                namedType.IsGenericType &&
-                (
-                   namedType.ConstructUnboundGenericType().Equals(
-                       m_reactTypes.IReactPromise.ConstructUnboundGenericType(), SymbolEqualityComparer.Default) ||
-                    namedType.ConstructUnboundGenericType().Equals(
-                       m_reactTypes.ReactPromise.ConstructUnboundGenericType(), SymbolEqualityComparer.Default)
-                ))
-            {
-                typeParameter = namedType.TypeArguments[0];
-                return true;
-            }
+        name ??= symbol.Name;
+        callbackContextName ??= defaultCallbackContextName;
+        callbackParameters = namedType.DelegateInvokeMethod.Parameters;
 
-            typeParameter = null;
-            return false;
-        }
+        return true;
+      }
 
-        private bool IsTaskType(ITypeSymbol type, [NotNullWhen(returnValue: true)] out ITypeSymbol? taskReturnType)
-        {
-            Contract.Requires(m_reactTypes != null);
+      return false;
+    }
 
-            if (type.Equals(m_reactTypes.Task, SymbolEqualityComparer.Default))
-            {
-                taskReturnType = m_reactTypes.SystemVoid;
-                return true;
-            }
+    private static void CollectTypes(INamespaceSymbol namespaceSymbol, ICollection<INamedTypeSymbol> result)
+    {
+      foreach (var type in namespaceSymbol.GetTypeMembers())
+      {
+        CollectTypes(type, result);
+      }
+
+      foreach (var childNs in namespaceSymbol.GetNamespaceMembers())
+      {
+        CollectTypes(childNs, result);
+      }
+    }
 
-            if (type != null &&
-                type is INamedTypeSymbol namedType &&
-                namedType.IsGenericType &&
-                namedType.ConstructUnboundGenericType()
-                  .Equals(m_reactTypes.TaskOfT, SymbolEqualityComparer.Default))
-            {
-                taskReturnType = namedType.TypeArguments[0];
-                return true;
-            }
+    private static void CollectTypes(INamedTypeSymbol type, ICollection<INamedTypeSymbol> result)
+    {
+      result.Add(type);
 
-            taskReturnType = null;
-            return false;
-        }
+      foreach (var nested in type.GetTypeMembers())
+      {
+        CollectTypes(nested, result);
+      }
+    }
 
-        private static bool IsSingleArgCallback(ITypeSymbol type, [NotNullWhen(returnValue: true)] out ITypeSymbol? parameterType)
-        {
-            if (type is INamedTypeSymbol namedType &&
-                namedType.DelegateInvokeMethod != null &&
-                namedType.DelegateInvokeMethod.Parameters.Length == 1
-            )
-            {
-                parameterType = namedType.DelegateInvokeMethod.Parameters[0].Type;
-                return true;
-            }
+    private bool TryFindAttribute(ISymbol symbol, INamedTypeSymbol attributeType, [NotNullWhen(returnValue: true)] out AttributeData? attr)
+    {
+      attr = symbol.GetAttributes().FirstOrDefault(potentialMatch => potentialMatch.AttributeClass != null && potentialMatch.AttributeClass.Equals(attributeType, SymbolEqualityComparer.Default));
+      return attr != null;
+    }
+
+    private bool IsAccessible(ISymbol symbol)
+    {
+      return symbol.DeclaredAccessibility == Accessibility.Public ||
+             symbol.DeclaredAccessibility == Accessibility.Internal;
+    }
 
-            parameterType = null;
-            return false;
+    private bool IsPromiseType(ITypeSymbol type, [NotNullWhen(returnValue: true)] out ITypeSymbol? typeParameter)
+    {
+      Contract.Requires(m_reactTypes != null);
+
+      if (type != null && type is INamedTypeSymbol namedType)
+      {
+        if (namedType.IsGenericType)
+        {
+          if (namedType.ConstructUnboundGenericType().Equals(
+               m_reactTypes.IReactPromise.ConstructUnboundGenericType(), SymbolEqualityComparer.Default)
+           || namedType.ConstructUnboundGenericType().Equals(
+               m_reactTypes.ReactPromise.ConstructUnboundGenericType(), SymbolEqualityComparer.Default))
+          {
+            typeParameter = namedType.TypeArguments[0];
+            return true;
+          }
+        }
+        else if (SymbolEqualityComparer.Default.Equals(namedType, m_reactTypes.ReactPromiseOfVoid))
+        {
+          typeParameter = m_reactTypes.SystemVoid;
+          return true;
         }
+      }
+
+      typeParameter = null;
+      return false;
+    }
+
+    private bool IsTaskType(ITypeSymbol type, [NotNullWhen(returnValue: true)] out ITypeSymbol? taskReturnType)
+    {
+      Contract.Requires(m_reactTypes != null);
+
+      if (type.Equals(m_reactTypes.Task, SymbolEqualityComparer.Default))
+      {
+        taskReturnType = m_reactTypes.SystemVoid;
+        return true;
+      }
+
+      if (type != null &&
+          type is INamedTypeSymbol namedType &&
+          namedType.IsGenericType &&
+          namedType.ConstructUnboundGenericType()
+            .Equals(m_reactTypes.TaskOfT, SymbolEqualityComparer.Default))
+      {
+        taskReturnType = namedType.TypeArguments[0];
+        return true;
+      }
+
+      taskReturnType = null;
+      return false;
+    }
+
+    private static bool IsCallback(ITypeSymbol type, out int parameterCount)
+    {
+      if (type is INamedTypeSymbol namedType &&
+          namedType.DelegateInvokeMethod != null)
+      {
+        parameterCount = namedType.DelegateInvokeMethod.Parameters.Length;
+        return true;
+      }
+
+      parameterCount = 0;
+      return false;
     }
+  }
 }